{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1649955728342,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "X-ulV3eB_Sk_"
   },
   "outputs": [],
   "source": [
    "## 算优势函数的均值 广义优势估计\n",
    "def compute_advantage(gamma, lmbda, td_delta):\n",
    "    td_delta = td_delta.detach().numpy()\n",
    "    advantage_list = []\n",
    "    advantage = 0.0\n",
    "    for delta in td_delta[::-1]: ## 从后往前逆序算，刚好可以算出广义优势估计的值\n",
    "        advantage = gamma * lmbda * advantage + delta\n",
    "        advantage_list.append(advantage)             ## 保存每一步的优势估计\n",
    "    advantage_list.reverse()\n",
    "    return torch.tensor(advantage_list, dtype=torch.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "executionInfo": {
     "elapsed": 7736,
     "status": "ok",
     "timestamp": 1649955738062,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "pJ6Z1jfP_SlD"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "import rl_utils\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "executionInfo": {
     "elapsed": 410,
     "status": "ok",
     "timestamp": 1649955894771,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "4zmEubV8_SlD"
   },
   "outputs": [],
   "source": [
    "## 构造智能体 agent 的大脑，也就是输入状态，返回该状态下，选择每个动作的概率\n",
    "## 输入是状态的，也就是 (车子center-point的坐标，车子的速度，杆的竖直角度，杆的角速度)\n",
    "## 返回值应该是2 dim\n",
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(PolicyNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return F.softmax(self.fc2(x), dim=1)  ## 返回该状态下，选择的动作的概率\n",
    "\n",
    "## 构造智能体 agent 的大脑，也就是输入状态，返回该状态下，每个动作的动作价值\n",
    "## 输入是状态的，也就是 (车子center-point的坐标，车子的速度，杆的竖直角度，杆的角速度)\n",
    "## 返回值应该是2 dim\n",
    "class ValueNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim):\n",
    "        super(ValueNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return self.fc2(x)\n",
    "\n",
    "class TRPO:\n",
    "    \"\"\" TRPO算法 \"\"\"\n",
    "    def __init__(self, hidden_dim, state_space, action_space, lmbda,\n",
    "                 kl_constraint, alpha, critic_lr, gamma, device):\n",
    "        state_dim = state_space.shape[0] ## 状态的dimension，CartPole-v1是2*2 dim\n",
    "        action_dim = action_space.n      ## 离散动作的个数，2个\n",
    "        # 策略网络参数不需要优化器更新\n",
    "        self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device) ##  策略网络不使用传统的 SGD 等梯度下降方式 \n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device)               ##  价值网络仍旧使用SGD ADAM等梯度下降方式 update\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)   ## 价值函数配置优化器\n",
    "        self.gamma = gamma   ## 衰减因子的呢\n",
    "        self.lmbda = lmbda  # GAE参数\n",
    "        self.kl_constraint = kl_constraint  # KL距离最大限制，对策略网络的参数update 做出相应的限制\n",
    "        self.alpha = alpha  # 线性搜索参数\n",
    "        self.device = device \n",
    "\n",
    "    def take_action(self, state):            # 根据动作概率分布随机采样\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.actor(state)       ## 拿到该状态下，每个动作的选择概率\n",
    "        action_dist = torch.distributions.Categorical(probs)    ##   配置 好采样的概率\n",
    "        action = action_dist.sample()        ## 对该状态下，所有的动作采样，采样的概率是probs\n",
    "        return action.item()                 ## 返回依概率采样得到的动作\n",
    "\n",
    "    ## old_action_dists 在传入前已经detach了，不需要反向传播求梯度，是KL散度的梯度\n",
    "    def hessian_matrix_vector_product(self, states, old_action_dists, vector):\n",
    "        # 计算黑塞矩阵和一个向量的乘积\n",
    "        new_action_dists = torch.distributions.Categorical(self.actor(states))    ## 策略网络给出选择动作的概率，然后依概率采样\n",
    "        ## 算出旧动作选择概率  和  当前动作选择概率的 KL散度，描述了两者的对齐程度，越相似值越小，差异越大值越大\n",
    "        kl = torch.mean(torch.distributions.kl.kl_divergence(old_action_dists, new_action_dists))  # 计算平均KL距离\n",
    "        '''\n",
    "        反向求策略网络参数的梯度，这是1阶导数的呢 \n",
    "        https://pytorch.org/docs/stable/generated/torch.autograd.grad.html?highlight=grad#torch.autograd.grad\n",
    "        torch.autograd.grad(output, input, ......)\n",
    "        create_graph=True，产生求梯度的图，允许求更高阶的导数，像二阶导数\n",
    "        kl：kl散度，也就是可导运算的输出，\n",
    "        self.actor.parameters()：策略网络的参数，也就是可导运算的输入，最后会返回该输入的梯度，而且梯度不会累加到参数的.grad变量，会直接返回的\n",
    "        '''\n",
    "        ##  此时反向传播求出的是 self.actor参数的梯度，也就是一阶偏导数，kl_grad: KL ---> new_action_dists ---> self.actor\n",
    "        kl_grad = torch.autograd.grad(kl, self.actor.parameters(), create_graph=True)\n",
    "        kl_grad_vector = torch.cat([grad.view(-1) for grad in kl_grad])  ##  一阶梯度全部列化，并且拼起来的\n",
    "        # KL距离的梯度先和向量进行点积运算\n",
    "        ## 这样就不需要存储二阶偏导数的矩阵了，向量先和一阶偏导数运算，然后再直接求二阶偏导的，此时二阶偏导也是个向量的，而不是矩阵了\n",
    "        kl_grad_vector_product = torch.dot(kl_grad_vector, vector)\n",
    "        '''\n",
    "        求策略网络参数的二阶导数，也就是二阶梯度，此时二阶偏导也是个向量的，而不是矩阵了\n",
    "        grad2:   kl_grad_vector_product--->kl_grad_vector--->KL ---> new_action_dists ---> self.actor\n",
    "        '''\n",
    "        grad2 = torch.autograd.grad(kl_grad_vector_product, self.actor.parameters())\n",
    "        grad2_vector = torch.cat([grad.view(-1) for grad in grad2])  ##  二阶梯度全部列化，并且拼起来的\n",
    "        return grad2_vector\n",
    "\n",
    "    ## https://zhuanlan.zhihu.com/p/657548225\n",
    "    ## 参数分别是 （grad：当前策略网络的一阶偏导数，states：当前状态的，old_action_dists：当前策略网络的动作分布）\n",
    "    ## old_action_dists 在传入前已经detach了，不需要反向传播求梯度\n",
    "    ## Hx = g，g=grad是使用策略网络算广义优势估计时的一阶偏导数，H是算KL散度时的二阶偏导数\n",
    "    def conjugate_gradient(self, grad, states, old_action_dists):  # 共轭梯度法求解方程\n",
    "        x = torch.zeros_like(grad)  ##  初始化线性方程组 Hx=g，需要求解的向量x\n",
    "        r = grad.clone()    ##  复制梯度的，初始化一阶偏导的残差，或者说是一阶偏导数\n",
    "        p = grad.clone()    ##  复制梯度的，初始化方向向量的\n",
    "        rdotr = torch.dot(r, r)  ## 初始化 beta 值，用来运算求出 下一个方向向量的，或者用来求出 alpha\n",
    "        for i in range(10):  # 共轭梯度主循环\n",
    "            ## 算出 alpha步长 分母需要的内容，p^THp 内的 Hp，也就是KL散度二阶偏导 H 和 优势估计一阶偏导g的的矩阵乘积\n",
    "            Hp = self.hessian_matrix_vector_product(states, old_action_dists, p)\n",
    "            ## 算 alpha也就是步长，在方向向量 update 的步长\n",
    "            alpha = rdotr / torch.dot(p, Hp)\n",
    "            x += alpha * p  ## update线性方程组 Hx=g 的答案 x，步长是 alpha\n",
    "            r -= alpha * Hp   ## update 一阶偏导的残差，或者说是一阶偏导数\n",
    "            new_rdotr = torch.dot(r, r)  ## 用来运算求出 下一个方向向量的，或者用来求出 alpha\n",
    "            if new_rdotr < 1e-10: ## 基本收敛的，此时alpha 步长也很小了，可以退出循环\n",
    "                break\n",
    "            beta = new_rdotr / rdotr  ## 用来运算求出 下一个方向向量的\n",
    "            p = r + beta * p  ## 求出下一个方向向量的\n",
    "            rdotr = new_rdotr  ## 赋值\n",
    "        return x ## 返回 Hx=g 这个线性方程组的答案 x\n",
    "\n",
    "    def compute_surrogate_obj(self, states, actions, advantage, old_log_probs,\n",
    "                              actor):  # 计算策略目标\n",
    "        ## 由于策略可能还没有update，也就是同一个策略，此时的 log_probs = old_log_probs, 像函数 policy_learn内的compute_surrogate_obj\n",
    "        log_probs = torch.log(actor(states).gather(1, actions))  ##  拿到选择的每个动作的概率\n",
    "        ## 若策略还没有update，残差是0，此时取指数就是 ratio = 1，像函数 policy_learn内的compute_surrogate_obj\n",
    "        ## 也就是 重要性采样，log相减也就是log内相除，最后取指数就是  (当前策略动作的概率 / 旧策略动作的概率)\n",
    "        ratio = torch.exp(log_probs - old_log_probs)  ##  当前策略动作的概率 - 旧策略动作的概率，并求e指数的\n",
    "        '''\n",
    "        ## 两个策略的动作概率残差取指数，当作优势函数值的权重，均衡当前的广义优势估计，也就是每一步优势的均值\n",
    "        若 log_probs - old_log_probs > 0，也就是动作概率变大了，则ratio > 1，此时放大了 广义优势估计\n",
    "        若 log_probs - old_log_probs < 0，也就是动作概率变小了，则ratio < 1，此时缩小了 广义优势估计\n",
    "        若 log_probs - old_log_probs = 0, 动作概率保持不变的，或者策略还没有update，则ratio = 1, 此时保持不变的\n",
    "        重要性采样 \n",
    "        '''\n",
    "        return torch.mean(ratio * advantage) ## 对广义优势估计做均衡化，并求出平均值\n",
    "\n",
    "    ## old_log_probs和old_action_dists 在传入前已经detach了，不需要反向传播求梯度\n",
    "    def line_search(self, states, actions, advantage, old_log_probs,\n",
    "                    old_action_dists, max_vec):  # 线性搜索\n",
    "        ## 拿到策略网络的参数，并向量化的，返回参数的向量，这个向量是列向量，也就是只有一列\n",
    "        old_para = torch.nn.utils.convert_parameters.parameters_to_vector(self.actor.parameters())\n",
    "        ## 算重要性采样，对广义优势估计做均衡，也就是两个策略的动作概率残差并取指数，当作均衡因子的，也就是重要性采样，用来算出广义优势估计的平均值\n",
    "        old_obj = self.compute_surrogate_obj(states, actions, advantage, old_log_probs, self.actor)\n",
    "        for i in range(15):  # 线性搜索主循环\n",
    "            coef = self.alpha**i  ## 搜索的相关因子，每次指数次 +1\n",
    "            new_para = old_para + coef * max_vec   ## 根号 * X，然后coef来调整，拿到update以后的策略网络的参数\n",
    "            new_actor = copy.deepcopy(self.actor)  ## 深度拷贝的网络\n",
    "            torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "                new_para, new_actor.parameters())  ## 将update以后的网络参数赋值给 深度拷贝的网络\n",
    "            new_action_dists = torch.distributions.Categorical(new_actor(states))  ## update以后网络动作的分布\n",
    "            kl_div = torch.mean( ## 算旧网络动作的分布，和update以后网络动作的分布，之间的KL散度，用来判断 KL 散度是否满足要求\n",
    "                torch.distributions.kl.kl_divergence(old_action_dists,\n",
    "                                                     new_action_dists))  \n",
    "            ## 使用update以后的策略网络来算重要性采样，然后算广义优势估计，用来判断优势是否上升\n",
    "            new_obj = self.compute_surrogate_obj(states, actions, advantage, old_log_probs, new_actor) \n",
    "            ## 若优势上升了，并且 KL散度也满足限制条件，就可以退出循环，并返回 update 以后的策略网络的参数\n",
    "            if new_obj > old_obj and kl_div < self.kl_constraint:\n",
    "                return new_para\n",
    "        return old_para ## 若是没找到满足条件的策略参数，那么就返回旧策略的\n",
    "\n",
    "    '''\n",
    "    old_log_probs和old_action_dists 在传入前已经detach了，不需要反向传播求梯度\n",
    "    '''\n",
    "    def policy_learn(self, states, actions, old_action_dists, old_log_probs,\n",
    "                     advantage):  # 更新策略函数\n",
    "        ## 算重要性采样，对广义优势估计做均衡，也就是两个策略的动作概率残差并取指数，当作均衡因子的，也就是重要性采样，用来算出广义优势估计的平均值\n",
    "        ## 此时策略的参数没有变化，所以此时的均衡因子是一\n",
    "        surrogate_obj = self.compute_surrogate_obj(states, actions, advantage, old_log_probs, self.actor)\n",
    "        '''\n",
    "        对重要性采样以后的广义优势估计的平均值，反向传播求出 策略网络 self.actor 参数的梯度\n",
    "        也就是 self.compute_surrogate_obj 函数内 log_probs = torch.log(actor(states).gather(1, actions)) 的梯度\n",
    "        拿到优势估计策略网络参数的 一阶偏导数\n",
    "        '''\n",
    "        grads = torch.autograd.grad(surrogate_obj, self.actor.parameters())\n",
    "        ## 对优势估计策略网络参数的一阶偏导数，列化，然后拼在一起的\n",
    "        obj_grad = torch.cat([grad.view(-1) for grad in grads]).detach()\n",
    "        \n",
    "        '''\n",
    "        求出线性方程组的解，不需要存储二阶偏导数的矩阵\n",
    "        参数分别是 （obj_grad：当前策略网络的一阶偏导数，states：当前状态的，old_action_dists：当前策略网络的动作分布）\n",
    "        old_action_dists 在传入前已经detach了，不需要反向传播求梯度\n",
    "        '''\n",
    "        # 用共轭梯度法计算x = H^(-1)g\n",
    "        ## Hx = g，g=grad是使用策略网络算广义优势估计时的一阶偏导数，H是算KL散度时的二阶偏导数\n",
    "        ## obj_grad 也就是使用策略网络在重要性采样广义优势估计时的一阶偏导数 g\n",
    "        descent_direction = self.conjugate_gradient(obj_grad, states,\n",
    "                                                    old_action_dists)\n",
    "        ## Hx   x^THx 内的 Hx，也就是KL散度二阶偏导 H 和 上面求出的线性方程组的答案 x，做矩阵运算的\n",
    "        Hd = self.hessian_matrix_vector_product(states, old_action_dists, descent_direction)\n",
    "        ## 求出策略网络参数 update 的步长，也就是根号内的内容\n",
    "        max_coef = torch.sqrt(2 * self.kl_constraint / (torch.dot(descent_direction, Hd) + 1e-8))\n",
    "        ## descent_direction * max_coef 是策略网络参数 update 时的内容，也就是 根号 * X\n",
    "        new_para = self.line_search(states, actions, advantage, old_log_probs,\n",
    "                                    old_action_dists,\n",
    "                                    descent_direction * max_coef)  # 线性搜索\n",
    "        torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "            new_para, self.actor.parameters())  # 用线性搜索后的参数更新策略\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        ## 拿到这条序列内的 奖励、状态和动作，下一个状态、是否完成的\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        \n",
    "        ## 用下个状态求下一个状态的状态动作价值，然后间接求出当前状态的状态动作价值\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 - dones)\n",
    "        td_delta = td_target - self.critic(states)  ## 间接求出的价值 - 直接求出的当前状态的状态动作价值，也就是 TD-error，或者是优势函数 A\n",
    "        ## 直接求出当前状态的状态动作价值，和 间接求出的价值，使用 MSE 来算损失函数的，td_target不反向传播求梯度，detach\n",
    "        critic_loss = torch.mean(F.mse_loss(self.critic(states), td_target.detach()))\n",
    "        self.critic_optimizer.zero_grad()      ## 价值网络的参数梯度置零的\n",
    "        critic_loss.backward()   ## 价值网络的损失loss反向传播梯度\n",
    "        self.critic_optimizer.step()  # 更新价值函数\n",
    "\n",
    "        ##  算出优势函数，广义优势估计，也就是每一步优势的均值\n",
    "        advantage = compute_advantage(self.gamma, self.lmbda, td_delta.cpu()).to(self.device)\n",
    "        ## 选择的旧动作概率的log值，不反向传播求梯度，detach\n",
    "        old_log_probs = torch.log(self.actor(states).gather(1, actions)).detach()\n",
    "        ##  配置 好采样的概率，方便后续依概率采样动作的，不反向传播求梯度，detach\n",
    "        old_action_dists = torch.distributions.Categorical(self.actor(states).detach())\n",
    "        # 更新策略函数 ## 不使用优化器来update，而是直接算的\n",
    "        self.policy_learn(states, actions, old_action_dists, old_log_probs, advantage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|                                                                              | 0/50 [00:00<?, ?it/s]C:\\Users\\10696\\AppData\\Local\\Temp\\ipykernel_24928\\2079941050.py:44: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ..\\torch\\csrc\\utils\\tensor_new.cpp:248.)\n",
      "  state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
      "Iteration 0: 100%|██████████████████████████████████████████| 50/50 [00:02<00:00, 21.57it/s, episode=50, return=92.900]\n",
      "Iteration 1: 100%|████████████████████████████████████████| 50/50 [00:03<00:00, 12.84it/s, episode=100, return=125.100]\n",
      "Iteration 2: 100%|████████████████████████████████████████| 50/50 [00:04<00:00, 10.69it/s, episode=150, return=130.600]\n",
      "Iteration 3: 100%|████████████████████████████████████████| 50/50 [00:04<00:00, 10.54it/s, episode=200, return=116.300]\n",
      "Iteration 4: 100%|████████████████████████████████████████| 50/50 [00:04<00:00, 11.09it/s, episode=250, return=136.900]\n",
      "Iteration 5: 100%|████████████████████████████████████████| 50/50 [00:04<00:00, 10.67it/s, episode=300, return=142.900]\n",
      "Iteration 6: 100%|████████████████████████████████████████| 50/50 [00:04<00:00, 10.22it/s, episode=350, return=146.200]\n",
      "Iteration 7: 100%|████████████████████████████████████████| 50/50 [00:05<00:00,  9.71it/s, episode=400, return=164.200]\n",
      "Iteration 8: 100%|████████████████████████████████████████| 50/50 [00:05<00:00,  9.43it/s, episode=450, return=183.000]\n",
      "Iteration 9: 100%|████████████████████████████████████████| 50/50 [00:05<00:00,  8.79it/s, episode=500, return=185.500]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1zElEQVR4nO3dd3jT1f4H8HfSNOlM96alpYwyCmKBWtmCTDd6FfEKgjLEBU68iqLeHziv14V6rwIqiKKgVxGUPcssZVMotBToXkln2ibn90eabxvSTduk4f16njxPvjMnX9B8+JzPOUcmhBAgIiIislNyazeAiIiIqC0x2CEiIiK7xmCHiIiI7BqDHSIiIrJrDHaIiIjIrjHYISIiIrvGYIeIiIjsGoMdIiIismsMdoiIiMiuMdghIrJR06ZNQ3h4uLWbQdThMdghsiEymaxJr+3btyM1NdVsn1wuh7e3N8aPH4/4+HiLe7/++utm57u4uKBXr1545ZVXoNVqLc4/efIkHnroIYSEhEClUiE4OBhTpkzByZMn2+NRNFtWVhaee+45REVFwcXFBa6uroiJicFbb72FwsLCVv2szz77DMuXL7fYv337drNn7OjoiC5duuDhhx/GhQsXWrUNbSkjIwMvvfQSRo4cCXd3d+nvHFFHpbB2A4ioxrfffmu2/c0332DTpk0W+3v27ImysjIAwOTJkzFhwgTo9XqcPXsWn332GUaOHImDBw8iOjra4jOWLl0KNzc3FBcX46+//sI///lPbN26FXv27IFMJgMArF27FpMnT4a3tzdmzJiBiIgIpKam4quvvsJPP/2E1atX4+67726jp9B8Bw8exIQJE1BcXIyHHnoIMTExAIBDhw5hyZIl2LlzJ/76669W+7zPPvsMvr6+mDZtWp3Hn3rqKQwcOBCVlZVISEjAl19+ifXr1+P48eMIDg5utXa0laSkJLz99tvo1q0boqOj6wyeiToUQUQ2a+7cuaK+/0xTUlIEAPHuu++a7d+wYYMAIObMmWO2/7XXXhMARE5Ojtn+e+65RwAQe/fuFUIIkZycLFxcXERUVJTIzs42OzcnJ0dERUUJV1dXcf78+Wv9eq2ioKBAhISEiICAAHH69GmL45mZmeLNN99slc8qKSkRQgjRu3dvMXz4cIvj27ZtEwDEmjVrzPZ/9NFHAoD4v//7v2Z93tSpU0Xnzp1b2twW02q1Ii8vTwghxJo1awQAsW3btnZvB1FrYTcWkZ0ZOnQoAOD8+fNNOv+WW24BAKSkpAAA3n33XZSWluLLL7+En5+f2bm+vr744osvUFJSgnfeeafRe2dnZ2PGjBkICAiAk5MT+vXrhxUrVpidY+qOe++99/Dll18iMjISKpUKAwcOxMGDBxv9jC+++AJXrlzBBx98gKioKIvjAQEBeOWVV6TtX3/9FRMnTkRwcDBUKhUiIyPx5ptvQq/Xm103YsQI9OnTB4cPH8awYcPg4uKCl19+GeHh4Th58iR27NghdVeNGDGiwTZe/YwBY3aod+/eUhfh3Llzm9TdZjAY8OGHH6J3795wcnJCQEAAZs2ahYKCggav++mnnyCTybBjxw6LY1988QVkMhlOnDgBAHB3d4e3t3ejbSHqKNiNRWRnUlNTAQBeXl5NOt8UFPn4+AAAfvvtN4SHh0tB09WGDRuG8PBwrF+/vsH7lpWVYcSIEUhOTsYTTzyBiIgIrFmzBtOmTUNhYSGefvpps/NXrVqFoqIizJo1CzKZDO+88w7uueceXLhwAY6OjvV+zv/+9z84Ozvj3nvvbdL3Xb58Odzc3DB//ny4ublh69atWLhwIbRaLd59912zc/Py8jB+/Hg88MADeOihhxAQEIARI0bgySefhJubG/7xj38AMAZUDbn6Gb/++utYtGgRRo8ejTlz5iApKQlLly7FwYMHsWfPnga/76xZs7B8+XI88sgjeOqpp5CSkoJPPvkER44cafDaiRMnws3NDT/++COGDx9uduyHH35A79690adPn4YfHlFHZe3UEhHVryndWIsWLRI5OTkiMzNT7Nq1SwwcOLDOrhRTN1ZSUpLIyckRKSkp4osvvhAqlUoEBASIkpISUVhYKACIO++8s8F23XHHHQKA0Gq19Z7z4YcfCgDiu+++k/ZVVFSIuLg44ebmJl1r+h4+Pj4iPz9fOvfXX38VAMRvv/3WYFu8vLxEv379GjynttLSUot9s2bNEi4uLqK8vFzaN3z4cAFAfP755xbnN9aN9fXXX4ucnByRnp4u1q9fL8LDw4VMJhMHDx4U2dnZQqlUijFjxgi9Xi9d+8knn0jXmlzdjbVr1y4BQKxcudLsczdu3Fjn/qtNnjxZ+Pv7i6qqKmlfRkaGkMvl4o033qjzGnZjkT1gNxZRB/faa6/Bz88PgYGBGDp0KE6fPo3333+/3kxHjx494Ofnh4iICMyaNQtdu3bF+vXr4eLigqKiIgDGboyGmI7XNYrL5I8//kBgYCAmT54s7XN0dMRTTz2F4uJii+6U+++/3ywbZcosNTaKSavVNtre2pydnaX3RUVFyM3NxdChQ1FaWoozZ86YnatSqfDII480+d4m06dPh5+fH4KDgzFx4kSUlJRgxYoVGDBgADZv3oyKigo888wzkMtr/hf82GOPQa1WN5gxW7NmDTw8PHDrrbciNzdXesXExMDNzQ3btm1rsF33338/srOzzUZW/fTTTzAYDLj//vub/T2JOgp2YxF1cDNnzsR9992H8vJybN26FR999JFF/UltP//8M9RqNRwdHdGpUydERkZKx0xBgynoqU9TgqKLFy+iW7duZj/ogHEkmel4bWFhYWbbpsCnsVoUtVrdaHtrO3nyJF555RVs3brVIljTaDRm2yEhIVAqlU2+t8nChQsxdOhQODg4wNfXFz179oRCYfzfrel79+jRw+wapVKJLl26WDyX2s6dOweNRgN/f/86j2dnZ0vfwzRaz3Rvb29vjBs3Dh4eHvjhhx8watQoAMYurBtuuAHdu3dv9vck6igY7BB1cN26dcPo0aMBALfddhscHBykOVIGDBhgcf6wYcPg6+tb5708PDwQFBSEY8eONfiZx44dQ0hICNRq9bV/gWoODg517hdCNHhdVFQUEhMTUVFR0WhgUlhYiOHDh0OtVuONN95AZGQknJyckJCQgBdffBEGg8Hs/NpZoOaIjo6W/kxak8FggL+/P1auXFnncVNB+dNPP21WCD58+HBs374dKpUKd911F9atW4fPPvsMWVlZ2LNnD/7v//6v1dtKZEsY7BDZmX/84x/4z3/+g1deeQUbN25s9vW33XYb/vOf/2D37t0YMmSIxfFdu3YhNTUVs2bNavA+nTt3xrFjx2AwGMyyO6auos6dOze7bXW5/fbbER8fj59//tmsy6wu27dvR15eHtauXYthw4ZJ+2uPkmoK03xELWH63klJSejSpYu0v6KiAikpKQ0GSZGRkdi8eTMGDx7cYCD2wgsv4KGHHpK2a3cP3n///VixYgW2bNmC06dPQwjBLiyye6zZIbIznp6emDVrFv78808kJiY2+/rnn38ezs7OmDVrFvLy8syO5efnY/bs2XBxccHzzz/f4H0mTJiAzMxM/PDDD9K+qqoqfPzxx3Bzc7MYEdRSs2fPRlBQEJ599lmcPXvW4nh2djbeeustADXZo9rZooqKCnz22WfN+kxXV9cWz8o8evRoKJVKfPTRR2bt+Oqrr6DRaDBx4sR6r/3b3/4GvV6PN9980+JYVVWV1KZevXph9OjR0ss0yaLp8729vfHDDz/ghx9+wKBBgxAREdGi70LUUTCzQ2SHnn76aXz44YdYsmQJVq9e3axru3XrhhUrVmDKlCmIjo62mEE5NzcX33//vVmtT11mzpyJL774AtOmTcPhw4cRHh6On376CXv27MGHH37YrKLihnh5eWHdunWYMGECbrjhBrMZlBMSEvD9998jLi4OAHDzzTfDy8sLU6dOxVNPPQWZTIZvv/220a6yq8XExGDp0qV466230LVrV/j7+0tz6TTGz88PCxYswKJFizBu3DjccccdSEpKwmeffYaBAweaZWSuNnz4cMyaNQuLFy9GYmIixowZA0dHR5w7dw5r1qzBv//970aH4Ds6OuKee+7B6tWrUVJSgvfee6/O80wBoml5kG+//Ra7d+8GALN5i4g6BKuOBSOiBrVkBmWTadOmCQcHB5GcnCyEqH8G5focO3ZMTJ48WQQFBQlHR0cRGBgoJk+eLI4fP97k9mdlZYlHHnlE+Pr6CqVSKaKjo8WyZcua/D0AiNdee61Jn5Weni7mzZsnunfvLpycnISLi4uIiYkR//znP4VGo5HO27Nnj7jpppuEs7OzCA4OFi+88IL4888/LYZXDx8+XPTu3bvOz8rMzBQTJ04U7u7uAoA0DL2+GZTr8sknn4ioqCjh6OgoAgICxJw5c0RBQYHZOfXNoPzll1+KmJgY4ezsLNzd3UV0dLR44YUXRHp6eqOfK4QQmzZtEgCETCYTly5dqvMcAPW+iDoamRDN/CcNERERUQfCmh0iIiKyawx2iIiIyK4x2CEiIiK7xmCHiIiI7BqDHSIiIrJrDHaIiIjIrnFSQRjXm0lPT4e7u/s1TQNPRERE7UcIgaKiIgQHB1ssOlwbgx0A6enpCA0NtXYziIiIqAUuXbqETp061XucwQ4gTVt/6dKlVl3FmYiIiNqOVqtFaGhoo8vPWDXYWbx4MdauXYszZ87A2dkZN998M95++2306NFDOqe8vBzPPvssVq9eDZ1Oh7Fjx+Kzzz5DQECAdE5aWhrmzJmDbdu2wc3NDVOnTsXixYuhUDTt65m6rtRqNYMdIiKiDqaxEhSrFijv2LEDc+fOxb59+7Bp0yZUVlZizJgxKCkpkc6ZN28efvvtN6xZswY7duxAeno67rnnHum4Xq/HxIkTUVFRgb1792LFihVYvnw5Fi5caI2vRERERDbGptbGysnJgb+/P3bs2IFhw4ZBo9HAz88Pq1atklbyPXPmDHr27In4+HjcdNNN2LBhA2677Takp6dL2Z7PP/8cL774InJycqBUKhv9XK1WCw8PD2g0GmZ2iIiIOoim/n7b1NBzjUYDAPD29gYAHD58GJWVlRg9erR0TlRUFMLCwhAfHw8AiI+PR3R0tFm31tixY6HVanHy5Mk6P0en00Gr1Zq9iIiIyD7ZTLBjMBjwzDPPYPDgwejTpw8AIDMzE0qlEp6enmbnBgQEIDMzUzqndqBjOm46VpfFixfDw8NDenEkFhERkf2ymWBn7ty5OHHiBFavXt3mn7VgwQJoNBrpdenSpTb/TCIiIrIOmxh6/sQTT+D333/Hzp07zcbJBwYGoqKiAoWFhWbZnaysLAQGBkrnHDhwwOx+WVlZ0rG6qFQqqFSqVv4WREREZIusmtkRQuCJJ57AunXrsHXrVkRERJgdj4mJgaOjI7Zs2SLtS0pKQlpaGuLi4gAAcXFxOH78OLKzs6VzNm3aBLVajV69erXPFyEiIiKbZdXMzty5c7Fq1Sr8+uuvcHd3l2psPDw84OzsDA8PD8yYMQPz58+Ht7c31Go1nnzyScTFxeGmm24CAIwZMwa9evXC3//+d7zzzjvIzMzEK6+8grlz5zJ7Q0RERNYdel7fJEDLli3DtGnTANRMKvj999+bTSpYu4vq4sWLmDNnDrZv3w5XV1dMnToVS5YsafKkghx6TkRE1PE09ffbpubZsRYGO0RERB1Ph5xnh4iIiKi1MdghIiIiu8Zgh4iIiFrEYBDQVemt3YxGMdghIiKiFrn3870Y+e52ZGvLrd2UBjHYISIiombLL6lAQloh0jXluGnxFvyaeMXaTaoXgx0iIiJqtgs5xdJ7gwBe+vk4KqoMVmxR/RjsEBERUbOdrw52nB0dAABllXocv6KxZpPqxWCHiIiImu18TgkA4P6BoRjbOwAAcCAl35pNqheDHSIiImq289nGzE6kvxsGRfgAAA6k5FmzSfVisENERHSdqdIb8Pev9mPRbyfN9v9wMA0T/r0Ll/JL6712w/EM3PXpHmw5Y1yAO9LPFbER3gCAQ6kF0Btsb2EGBjtERETXmUMXC7DrXC6W7Uk1C06+2p2CUxlabD+bU++1c1YmIPFSIQDA0UGGvp080TNIDXeVAkW6KpzO0LZ185uNwQ4REdF1pvaoqbxiHQBAU1aJc9VdU1maps2bE9PZC24qBRzkMgwI9wJgm3U7DHaIiIiuM4VlldL7jOrAJvFSIUxLg2c0EOx09nGR3vcP85Lem+p29p7Pbc2mtgoGO0RERNeZ/OpsDlAT2CRcLJD2ZTUwI3JphXF5CD93FWYO7SLtHxnlBwDYcTYHhaUVrdrea8Vgh4iIqAMQQuCDTWfxbXzqNd8rv6QmGMnUlAEAEtJqgp3MBoIdTXVWaN3jN8PLVSntjwpUIyrQHZV6gd+PZVxzG1sTgx0iIiIbd+KKBl/svICPtpzDq7+ebDDz0hR5tYKdDG05DAaBxLRCaV9mPd1Y5ZV6qd5H7exocXxidBAA4FCqbdXtKKzdACIiIqqfEAK3fbzbbN+G4xmYNjiixfesndn5YscFBKqdUKSrgkohh67KgGJdFYp1VXBTmYcJ2nJjVkcuA9yUliGEv1pVfV5Vi9vWFpjZISIismHZRTqLfeuPZ0AIgbS8UgjR/Hltamd2AGDRb6cAGEdXuVcHOHVld7TVXVjuTo6Qy2UWx92djNmeovJKi2PWxGCHiIjIhp3NKrLYd/hiAZbuOI9h727DZ9vPN/ue+SV1FxAP6eaLQA8nAEBqbonFcU2ZMWPjUUcXFgC4OxkDpSJmdoiIiKgpdpzNwd+/OmCx3yCAdzYmAQDe/TOpWff8764LSK6eT+f5sT0wa7hxRNXNkT54dEgXDKqeDXlrUrbFtabMjtq57ioYU7eXrQU7rNkhIiKyUfN+SLTYN3lQKL4/cKlF9xNC4K31p6Xtvw0Iha+bErf3DUaPQHc4OsgxpncgVu5Pw6ZTWXjrzj6QyYD4C3lIuFiACr2xy0ztVF9mxza7sRjsEBER2aja3U2TB4Xitr7BcJDLLIIdIQRkMssamquZ5sgBgEC1E7xdlZDJZOgT4iHtj+viAxelA3KKdDifUwxteSUe/M9+s/vU142lru7GKtZVNblN7YHBDhERkQ0SQkCpkKOiygB3JwVeHBcFTxclyiv1FufmFOvg5OiA4vIqBHs613vPglqT/e14YQQc6igyVirkCPJwwvmcEuQWV+BUHWtdNZbZMQigpEJvMZrLWlizQ0REZIMKSyulOW0OvTIani7GCfycHB2guCpISc0txf1f7MPI97YjLa/+FcsLS43dS/7uKqgUDvWe51X9WQWlFUjONhZI394vWDqeX88MyU6OcqltttSVxWCHiIjIBmUVGYd+e7sqLQKTgeHeZtsr9qbidIYWuioD1h+vf/ZiU7BjCmbqY5oZ2RjsGIuZR/f0x7SbwwHUTB54NZlMZpMjshjsEBER2SDTPDf+7iqLYx/c3w9DuvoizNu4KGftAGfXuZx672nqxvJ0qbsbysS7OhjKL66QVkLv6u+G127vhV0vjMSdNwTXe62pK+uXI1dgMDR/DqC2wGCHiIjIBpmWhDDNe1NbkIczvns0Fqtn3mQRDB1IyUeJru6simmBzsYyO56uxoAlOacYhaWVkMmASD83yGQyhHq7NFh4bMrsfLb9PJbtTW3wc9oLgx0iIqJrdC6rCGP/tRMv/HQUecWWMx63RJbWeJ9AtWWwYxLs6YyfZt+MRXf0xtHXxiDIwwlVBoETVzR1nl9Q3Y3V1MzOzrPGLFG4jyucHOuv8anNFOwAwHf7LjbpmrbGYIeIiOgabT6djaSsIvx46DK+3HWhVe5pWnncv4FgBwDCfFww9eZweDg7SkPI95zPw5u/n8LWM1lm59Z0YzW1ZscYHA3v7tfkdlfqa7quagc+1sRgh4iI6Brl1Fq/Kq+47pFKzZWUaRwFFeHr0uRroquDnY+2nMNXu1Mw/8ejKKs1t05NgXLDmZ2ru7lG9wxochsu5BRL71vrWVwrBjtERETXKLuoZtHM+uplmqNSb5C6ovp28mzyddG1JgcEjMFNz4UbsSc5F78dTce6I1cANF6z4+1aEwy5qxTSEhJNUXvCwSuFZXXOC9TeGOwQERFdo9orkxe3QrBzNqsIuurJBCN8XJt8Xd9OHtI8N7f1rRke/o91x/H06iPSdmM1O7W7uYZ194NS0fRw4YP7b8CAzl7SdkodC4q2NwY7RERE16h2N1ZrzC9zJK0QgDF4kdcxy3F9fNxUWDF9EH6cFYd/P9AfC2/rBQBIzStF7VHgDc2yDNQUKAPAqJ7+TW84gBvDvPDTnJvRP8wTgG0EO7ZROURERNSBZWtrurGuNbOTXliGDzadBQAMCvdp9vWDu/pK76cPiUBZpd5sZfQP/tbPbC2sung4OyJQ7YSSiiqM7NG8YMckwtcVR9IKzWp4rIXBDhERUTMIIZCaVwoXpQMC1E4o0VWhpFYRcPE1ZnbWHbmC/JIK9AxS49GhEdfaXDw6NAIfbj6LSr3A82N74J4bOzV6jVwuw09z4qA3CGlkVnN18TV2v11gZoeIiKhjeenn4/jh0CW4Kh2w+8VboCkzXwOqKZmdLaez8J9dF/Duvf0Q6m0+2upslmktqiC4tsJCmiqFAzbNG45fE9PxyODwJl/Xyavpo8Dq0sXPDYBtdGNZtWZn586duP322xEcHAyZTIZffvnF7LhMJqvz9e6770rnhIeHWxxfsmRJO38TIiK6XmxLygZgXNU78VIhLhUYF940rfBdrKtqdJmEGSsOYd+FfLy87rjFsXNZxm6fbv7urdbmcF9XPD26G1yU7ZfjiDBldnJKIIR1l42wamanpKQE/fr1w/Tp03HPPfdYHM/IMF/MbMOGDZgxYwYmTZpktv+NN97AY489Jm27u7feXxAiIiKTKr0BubVmSH5k+UHpfRc/Vxy7bBwuXlqpl4KfhpypnkvHRG8QOJ9TsxZVRxZePYpMU1aJgtJKeLewO6w1WDXYGT9+PMaPH1/v8cDAQLPtX3/9FSNHjkSXLl3M9ru7u1ucS0RE1NpyinWoL2nTK0iNU+laVBkEisur6g12amc5Sq/q8jINOVc6yBHq1fCIKVvnrHRAsIcT0jXlSMktsWqw02GGnmdlZWH9+vWYMWOGxbElS5bAx8cH/fv3x7vvvouqqob7S3U6HbRardmLiIioMab1qurS1d8Nbk6mrqzKes/T1ipgLqnQS11el/JLMf7fuwAYs0QKhw7zE10vdfUEg60x0eK16DAFyitWrIC7u7tFd9dTTz2FG2+8Ed7e3ti7dy8WLFiAjIwMfPDBB/Xea/HixVi0aFFbN5mIiOxMpqa83mPdAtzhqlSgsLSywbl2MjRlZtunMrTwdVPhz5OZ0r77BoRee2NtgGnxUF2Vwart6DDBztdff40pU6bAycl8QbT58+dL7/v27QulUolZs2Zh8eLFUKlUV98GALBgwQKz67RaLUJD7eMvFhERtR3TshC+biqz2h3AmNlxd6opUq5PRqF5wHTbx7vhrlIgpLrb6pWJPTFjyLUPObcFquqZl629ZESHyJHt2rULSUlJePTRRxs9NzY2FlVVVUhNTa33HJVKBbVabfYiIiIyqdIbMO+HRHyx47zZflNmJ6azp8U1wR5ONSOyGsjsXCkss9hXpKuSipWHNWOFcVvHzE4zfPXVV4iJiUG/fv0aPTcxMRFyuRz+/i2b8ZGIiGjXuVxp0cyHbuoMJ0cHOMhlyKyeKblvJ09kaMqRpS2HrsqAW6L8IZPJpJqdogYyO+eq59EZ3ycQG05kmh0L83ZBtw4+Cqs2W8nsWDXYKS4uRnJysrSdkpKCxMREeHt7IywsDICxi2nNmjV4//33La6Pj4/H/v37MXLkSLi7uyM+Ph7z5s3DQw89BC8vL4vziYiImiK9Vl1N79f+xMxhXfDyhJ7Iri5QDlQ74ZfHBwMADEJIxcSmzE59Bbn7L+Thm30XAQDjo4Nwe79g7E7OxdqEy5BBho8n94dM1vS1sGwdMzsADh06hJEjR0rbpjqaqVOnYvny5QCA1atXQwiByZMnW1yvUqmwevVqvP7669DpdIiIiMC8efPM6nGIiIiaKyXHfNbfL3dewMsTeqKgtAIA4O2mlBbolKMmOPFzN9aKnkqvGeX7310XkF9SgWmDw7HxZCaEACZGB+H2vkGQyWSYEB2EOcMjAcBiNuWOjpkdACNGjGh0VsWZM2di5syZdR678cYbsW/fvrZoGhERXceS61i8MlNTjsJS45Byz+oh1Vcb1zsQy/akYuOJTLx5Vx/kFOnw1vrTAIxdYx7V1w3v7meWwbG3IMeEmR0iIiIblZxtGewkXiqAtnodLE+XuifIGxjujRBPZ1wpLMP2pBw4OtQENMevaKT33QLspy6nIabMju56zuwQERHZkn0X8pB4qRCXCyxHTO27kC8VHteX2ZHLZbg50gdrDl/Gsj0pyKhnXp5uAdfHskbM7BAREdmYB76svzRi+d5U6b26nmAHMC66CQD7U/LrPB7i6dykdbPsga3U7HSIeXaIiIjKK/V4fs1RbDie0fjJLZCtNc/CPBgbhl0vjMTR18agS3UAAwDuTgo4yOsfMVX7XJPakwT2Dr5+5nZjZoeIiKgZvtt3EWsOX8aaw5eRumRiq9//ZIb5OolDuvpKhcN39Q/BB5vOAgA8XerP6gA1mZ3a/jYgFOP6BOLYZQ3G9ApopRbbPpWjbWR2GOwQEVGHcL7WCCkhRKvPR1N7uHiAWoUh3Xyl7c4+NaOlPJ0bXr073Mc82Lklyh9d/d3gIJdhYLh3K7W2Y3BS2EZmh91YRETUIZRV1GQHcosroDcIpOaWSFOYnLiiwYlaI56a62S68dr5t3bHtudGQO1Uk8EJqzU03KOBeh0AcFY6SO+n3RyOr6cNbLDby56ZMju6KtbsEBERNepSrRFSlwtKsWTDaYx4bzseX5mAnCIdbvt4N277eDdKK+pfqqEh57ONEwn27eQBF6V5x0ftYMdUh9KQuSMjEebtgjkjIlvUFnuhqs7slFeyZoeIiKhRKbk1sxpfLijD5tPZAIANJzJRZaiZoDY5uxhKhRwzvzmMCF9XJGUW4YVxPXDPjZ3qvbcQApcLSgGYBzYm3q41XVf1LQVR2/Njo/D82KjGv5Sds5XMDoMdIiKyeYWlFcgvqZC2z2YV4WJeTfCz6VRWrWPF+G7fRaTllyIt3xjAzP/xKEI8nRHbxaee+1eipLqbLNjT2eJ47fogTfXEgtQ4JxvJ7LAbi4iIbN7Gq1YH33giE4Z6Vhs6l1WE9ELLSQF/Trhc7/0vVWd1/N1VjXZT1ZX5obrZSmaHwQ4REdkMg0EgObvYbN3E8ko9Ptt+HkDNHDXnqpdzGNDZy+IeRy8XmmWBTDadykKVvu4Mg2nG5E5ellkdk5/nxOG2vkF47Y5eTfw2xMwOERHRVX5OuIzRH+zAy+tOSPuWbDiDtPxS+Lqp8O2MWLMA567+IegZZAyAJg8KA2Bc1qF2DY+3qxLerkoUlFbWO6uxqV4nxKv+rE1MZ2988uCNCPKoPyAic1Jmh/PsEBGRNa0+kIa1R65gaFdfzB4RCUeHtv93cEWVAWWVeoth3Kbam+8PpOFvAzohzNsF38SnAgDeva8vvF2V+O7RWPx5MhNh3i64IdQTw7v74VJBKfp18sTvx9JRVG4sIB4Y7gUnRwe8OC4K3+27iNUHL+Ffm87C3UmBvp08zT73+BXjHDsNZXao+UxdguWcQZmIiKxl06ksvLT2OADgQEo+HBxkeHxE1zb/3Hk/JGLrmWz88fRQRNSacdhRURNoLd1+HjGdvWAQxu6rkT38ARh/QO+8IUQ6L9TbRZrpePbwSLz7ZxIA4KPJ/aUszLg+gVh98BIOXSzAvUvjcfAfo6F2VuBgagHS8kvx29F0AED362Q18vZiWhurosrQJhNBNhWDHSKi65TBILBkw2mzfR9tOYcpsZ0bnTjvWlRUGbC+en2rr3en4M27+kjH8op10vu/TmXhr+pMz5hegU2696NDI6Atq8QNoZ5m3U03R/rC08URhaWVqNAbcDJDg8LSSjy+MkE6Z2g3X9zeN/iavhuZq13srasyNGmOorbAmh0ioutMemEZFqw9hnf+TML5nBK4qxQ4/voY+LqpUF5pwKXq4dpt5WxWkfQ+Lb8Uuio9Fm84jQ3HM5BbbFlYrJDLMCG6acGOSuGABRN6Ynx0kNl+pUKOr6YOkLZPpWuxan+a2TnPjekBRTt04V1PVLUydTorFikzs0NEdB3Rlldi2DvbzAp4J8V0gruTI3zdlMgt1tU5kqk1Hb1cKL0/mJqPD/46iy92XgBQs8jmsmkDkZJbgv5hnnBWOqBbgPs1f25MZ2/Mv7U7Pth0FqfStRYLepoKnan1KOQyyGWAQQDlVXp4oO0yhg22wyqfSkREVrH7XK5ZoAMAI6OMtTCmWYILSts42LlUKL0vrdBLgQ5gnNwPAKI7eUjtak2moesn07VwczL/CVQqmNVpbTKZDE6ODiit0DOzQ0RE7eN8drHFvpjqodxe1cFOW2d2Dl8sAAD4uCqRV8dnyWWAl0vDK4u3VHSIBwDgbHYRak3lg5fGc2mHtqJSyFFaoUe5FScWZLBDRHQdOZ9jGey4qYw/Bd7VAUZBGwY7ucU6nM8xLvPw+h298eT3RyzO8XZVttkq4f5qJ4zuGYDNp2uWl/h17mD0qQ6CqPXtfvEWKBXydpnSoD7M2RERXUdMgca0m8MhlwFv3NlbOiZldtqwG+tg9aR+UYHuGN8nED2D1Oji54rnxnSXzvFxVbXZ5wPAk7eYD63v28mjzYIrAlxVCqsGOgAzO0RE1w0hhJTZeeimznj9jt5mx72rC3YLStpmoUshBP5XPZ/NoAhvKBzk+OOpITAI4wit9/46CwAoa+PZdvuFemJguBcOphbARelgtblfqP0ws0NEdJ3I1JajtEIPhVyGzj6WyyK0Zc1OUmYRBi/Zig0nMiGXAXf0M85nI5PJ4CCXoWeQGm/c2RtyGXDnDW0/181/Hx6Ivw3ohH8/0L/NP4usj5kdIqLrxPlsYxdWmI9Lnd0KbTka64/jGUjXlAMA/u/uaAwI97Y45+G4cNzRL7hNJzQ08XBxxDv39mvzzyHbwGCHiOg6YerC6uJb95IIphFQbZHZuVS90ObckZF4oHrBzrp4ttEoLLq+sRuLiOg6YQp2Iv1d6zzuVSuzI4So85yWMs3KHBXIifuo/THYISK6TlyoHokV6Vd3ZsenOtip1Atpcr/WklYd7IR5W9YKEbU1BjtERNcJKbNTT7Dj5OiAEE/j4pnnsouRV6zDCz8dRWKtGY9borxSjyytcYHPUAY7ZAUMdoiIrgM5RTpkVBcIR/rV3Y0FAN0CjIHQ2awivPjzMfx46DL+/t/91/TZl6vrddxUCni5WGdtJLq+MdghIroOmFb47h/m2WARcPfqBTfPZRVh8+lsAECRrqpFnymEwH93XcDjKxMAGLM6nNOGrIGjsYiI7JyuSo9v910EADwyOKLBc7v5GzM7ZzKLrvlzj13W4K31p6Xt8X0Cr/meRC3BYIeIyM79fjQDucU6BKqdGg04TJmd/dXLOgCAg1wGIUSzszLxF/Kk9/9+4AZpIkGi9sZuLCIiO/dNdVbn4Zs7N7pGUV0zK+sNAtry5ndl7asOdl69rRfuvCGEXVhkNQx2iIjsWH5JBY5Wj6a6N6ZTo+d7ODtCqbD8acgp0jXrc6v0BmnRz5u6WM6WTNSerBrs7Ny5E7fffjuCg4Mhk8nwyy+/mB2fNm0aZDKZ2WvcuHFm5+Tn52PKlClQq9Xw9PTEjBkzUFxc3I7fgoio/Ry+WIB7PtuDwxcLmnS+KbvSI8Ad/u5OjZ4vk8kQoLZcdTy7qLxZ7TyZrkVJhR4ezo7oyYkEycqsGuyUlJSgX79++PTTT+s9Z9y4ccjIyJBe33//vdnxKVOm4OTJk9i0aRN+//137Ny5EzNnzmzrphMRtTshBCYt3YuEtEL83x+nGzy3Um/ApfxSxJ83BjtxkT5N/pyAOoKi5mR2yiv1+P2YcXXzgeHekMvZfUXWZdUC5fHjx2P8+PENnqNSqRAYWHdB3enTp7Fx40YcPHgQAwYMAAB8/PHHmDBhAt577z0EB7MYjojsx65zudL7ovL6Zzg+k6nFjOWHcKWwTNrXrGBHXRPsqBRy6KoMTQ52SiuqcM9ne6XRXOzCIltg8zU727dvh7+/P3r06IE5c+YgL6+muj8+Ph6enp5SoAMAo0ePhlwux/799U+CpdPpoNVqzV5ERLaudteVpswY7Ly87jju+WwPyir00rFfE9PNAh1HBxkGd/Vt8uf41+rG6tvJAwBwuaCsvtPNvLMxyWzY+k1dmh5kEbUVmw52xo0bh2+++QZbtmzB22+/jR07dmD8+PHQ643/UWdmZsLf39/sGoVCAW9vb2RmZtZ738WLF8PDw0N6hYaGtun3ICJqDbUDjiytDml5pVi1Pw0JaYWIv1CT9ckoNA9Mgj2d4aZqeiLf160m2LmtrzFD/r+j6Siv1Nd3CQDAYBD4NfEKAGBoN1/MG90dvYNZr0PWZ9Pz7DzwwAPS++joaPTt2xeRkZHYvn07Ro0a1eL7LliwAPPnz5e2tVotAx4isnmmZRdMVsSnSu9TcmuOpWvMi4nv6d/4KKzaHGrV2DwwKBRf7ryAK4Vl+O1oOu4bYPn/Sr1BwEEuw8l0LQpKK+GmUuDraQMbHeZO1F461N/ELl26wNfXF8nJyQCAwMBAZGdnm51TVVWF/Pz8eut8AGMdkFqtNnsRETWVrkqPdzaewdYzWe36uVeuyth8tTtFep+UWdMdn6Exnvev+/th4W29MGdEZLM+p3ZmR6VwwAMDjQHO+uMZ0v4DKfk4flmDU+la9Fq4Ee/+eQY7z+UAMNYHMdAhW2LTmZ2rXb58GXl5eQgKCgIAxMXFobCwEIcPH0ZMTAwAYOvWrTAYDIiNjbVmU4nIji3dfh6fbT8PADi5aCxcm9FF1FJVeoO0kOeQrr7YnZxrdjypuk7GYBDI0hiLiQeGe6OTV/NXGb+jXzB2ns3BzdVFzeOjg/D+prPYk5wLTVkldJV6/O2LeADAtJvDoasy4NNt56Xrh3f3a/4XJGpDVg29i4uLkZiYiMTERABASkoKEhMTkZaWhuLiYjz//PPYt28fUlNTsWXLFtx5553o2rUrxo4dCwDo2bMnxo0bh8ceewwHDhzAnj178MQTT+CBBx7gSCwianVVegMWrD2ODzefk/b9nHC5zT/XYBB47X8noTcIKB3kWHRnb2mm4wdjwwAApzOL8MGmszh0sQAVegNkMvNRVc2hVMjx0eT+eGCQ8d5d/d3Qzd8NlXqBrWeycOyyRjp359kcs2s7+7g0afJCovZk1czOoUOHMHLkSGnbVEczdepULF26FMeOHcOKFStQWFiI4OBgjBkzBm+++SZUqpoU68qVK/HEE09g1KhRkMvlmDRpEj766KN2/y5EZN/+uf4U/rMrxWL//xLT8XBceJt+9l+nsrCyetVyuRyI9HPDX/OGIUujQ7CnE/46mYnc4gp8tOUcPtpiDMT83FSt2pU0rk8gzm1NxvpjGQj3cZX2X8gtkd73CVFj0R294eTo0GqfS9QarBrsjBgxAkKIeo//+eefjd7D29sbq1atas1mERGZ0VXpzepjXr+9F+IifTH2w504naGFwSBadeI8IQQq9AaoFMagoXatzK29jPWIKoUDwqqzO789OQRbTmfjn+tPo6x6xFSQp3OrtQcwBjsfb03G5tPZdR7/eU4cYjpzTh2yTR2qZoeIyBpOXNHAUP3vss+m3IgJ0UGo0hugUshRUqHHxfxSRPi6NnyTRhgMAr8evYL9F/KhLa/EtjM5WDM7DpF+bthy2lgI/eZdfXB3/xCLa4M8nPHQTZ2x82wO/jplPLern9s1tedqvYLUiPB1RUqtTE5tYd7X9v2J2hKDHSKya0IIvPjzMVQZBN6/r1+LVt4+lGqczG9MrwBMiDYOkFA4yBEVpMbRS4U4ma5pcrCTmluCDScycTA1H85KB3x4/w1wdJBjzeFLePHn42bnfrHzAib0CURphR4hns54KDaswfaPjw6Ugp1nRndr9vdsiEwmw+cPxeCvk5lYEZ8KB7kMucUV0FdHgb5uylb9PKLWxGCHiOxauqYcPx4yFhG/NC4K/vUU7Z7J1OJKQRl0VQZ09XdD9wB36djBVOPq3QPCvcyu6SUFO1pp8r3GPLfmKA7Vmgl5RHc/3DcgFCfTLWdy33giA1la4wis2/oGNRqo3dEvBJkaHeIifRDq3fxRWI3pEeiOHoHueHRoFwDA5zvO499bzsHJUd6iIJKovTDYISK7diajJohI15TD21WJHWdzMKCzNzxcHAEYR1lN/nIfCkqNSzBE+Lpi23MjABjnrNmeZBxxNOyqIdX9Qz3x/YE07D6XixfHNd4WvUHg+BWN2b6l28/j3phOuJRfanF+pV7gQIox0JrYN6jR+zvIZc2eU6clnJXGWqInb+kKZ6UDBkWwVodsG2d9IiK7lJRZhA83n8XyvanSvozCMizfm4oZKw5h5reHpP1XCsukQAcAUnJLoKsyFvp+t+8iqgwCN3XxRlSg+QSko3r6w0Euw/ErGlzMq7uWpbaLeSXQVRng5CjHsdfHQCGX4UJuCTI05UirI9gx6dfJA9EhHk396u1G4SDH7OGRuDHMq/GTiayIwQ4R2aXX/3cSH24+Z7ZSeLqmHN8fMA7h3l+dMQGA1DxjoNHN3w3O1cOm0wvLoTcI/HTY2AU2tY7h5T5uKsRVL3T5x/H61+MzMU38183fHWonR3Sr7io7mJovBTtT4zrDQS7D94/dhCAPJzg6yPDPu6PZTUR0DRjsEJHdEULgVIZlDUx6YZnZ3DOmqS9ScooBAOG+rgj1Ng7ZvpRfivjzecjS6uDh7Ihbevpb3A8ARlfvj7+Q12i7krKMwU6PQGOQEx1izBQ9vToRlXrj+lKv3tYL5/9vAuIiffDL3MH4a95w9LHBrA5RR8KaHSKyO7nFFdCU1dTfmIZLfxt/EQqHmgzJ8SsaLPrtFA5XFwyH+7hAbxA4m1WMGSsOwt/dWMx8W98gac6bq8VWZ3YOp+ajSm+AooGJ/EyfEyUFOx5S8TRgrOmpfX1LZ0AmInPM7BCR3UnONmZqwrxdsOHpofjw/hsAABV6A0or9NJ5D3y5TwpAAKCzjytCvYyZnUq9kBbeNC3JUJceAe5QOylQUqGvc0QVAJRV6PHm76ew61wuZDLglihjNqhvJ0+z8/p1YgaHqC0ws0NEdie5uluqq78bnBwdEFnPBHu1Ax8ACPV2QbGuymzfoHBv9A6uPwiRy2UYFOGNzaezcehiAfqFelqc86/NZ6UZmG/rG4wu1e3p28kDr9/eC77uKpzPLsGY3gFN/o5E1HQMdojI7iRnmQqBjUFFtwA3dPF1NVvHySSuiw/cnRQ4nanFjWGeKCytkI5NiQ3DI4MjGv28XsEe2Hw6G2erC5BNhBD461QWvtx5AQDQO1iNlydEScdlMhmmNeH+RHRtGOwQkd1JqR5dZZrV2MnRAVueHY6JH+2WCpflMkAAmDY4HGN6BUijnSZGB+FUhhZDu/phSDffJn1e9wBjUHU22zzYib+Qh1nfHgYAdPFzxW9PDGnVNbSIqGkY7BCR3blcPYzbtFAmYMyi3N0/BKcytHB3UmD3i7cAADycHc2uVTjIsWB8z2Z9nmm25XNZxRBCSIHT/gs1w9v/eVc0Ax0iK2GwQ0R2RW8QuFxgLCwOu2rJhBlDIuCqUmBQhLdFkHMtwn1coZDLUKyrQrqmHCHVK46bZks2rpLu02qfR0TNw9FYRGRXsrTlqNAboJDLEOThbHZMLpfhwdgwdPVv3RXBlQq51GWWlGnsJhNC4NhlY7ATfdWoKyJqXwx2iMiumGYi7uTlDId27DbqH+YJANI6WpnacuQW6+Agl6FXkLqBK4morTHYISK7Ygp22mLV74ZMiDYu1PnH8UzoDTVZne4B7tLCmURkHQx26Lq1+kAalmw4A4NBSPsMBoFDqfmo1Bus2DK6mhACB1PzUXLVHDh1OXqpEIBlvU5bG9zVFx7Ojsgt1mHn2Rwcrw52+nKpByKrY7BD16WCkgq8tPY4Pt9xHnvP16xp9NXuFNz7eTz+vflcs+9pWmeJWo/BICCEwCdbk3Hf5/EY8NZmPLP6CDaeyKjz/AMp+VhVvdDnqHrWsmorjg5y/G1AJwDAJ9uScfRyIQAgmrMiE1kdgx26Lv11qmaF6oe+2o+Xfj6Gsgo9/vnHaQDGH6vmBC9Tvz6AEe9th7a80ixTRC2nKavEiPe2o8vLf+D9TWcBAGWVevySmI7Z3yXgr5Pmq4wbDAJv/H4SQgB/G9AJt0S1/2zEjw3tAqVCjsMXC6TV1vsy2CGyOgY7dF367ah5ZmD1wUvo8/qfZvtOZ5hPEFcfTWkldpzNwcW8Uvzz99MY8vZWPPvjUWZ6rtGKvalIyy9FfY/xj+Pmf4bbz2bjxBUt3FQKvDguqu6L2pi/2gkzh3aRtpUOcmmFcyKyHs6zQ9ed5Oxi7E7Otdivvyojs3THeXz0wA3SBHH1ScqqCYp+OHQJAPBzwmVsPJGBT6fciBE92rc7xR4U66rw9R7jWlL3xnTCtJvD0SfEA9lF5TifXYLJ/9mH3cm5MBiENFHfvuoJ/G7vFwwfN5XV2v7ELV2xOzkXOUU6PDO6W72rpRNR+2GwQ9eNovJKbDieiRd+PgYAuLVXAG7tFYCyCj0i/dzw+MrD6BPigYfjwjF3VQJ+O5qOQRHe6NfJw2J16tpM86pcraRCj3+sO4Htz4+AowOTqM2xct9FFJZWoouvK96e1FcaQu7v7gRPZyVclA7ILa7AqQwtlAo5FHIZjqQZVy+P6exlzabDydEBv8wdbNU2EJE5Bjt0Xdh5NgcPf33AbN/jIyLRP6zmh/HIwjHSj+q0m8Px1e4UvPrLCchlwC9zB9cb8JypXvxR7aTA7BGRmBoXjp8TLmPhrydxpbAMc1cm4N8P9LfL4ceZmnL8mngFD8aGwd2pdWYkFkJg+d5UAMDjI7tazJWjVMgxKMIb25NysPm0cZHN2quXm+a7ISIy4T836bqwrLpLxGT/y6PMAh0AZj+qfxsQKr03COC/u8yvB4wz9f5wMA0n0o2ZnTfu7IPHR3SFq0qBh+PC8X93RwMA/jqVhU+3Jbfad7EV5ZV6TFt2AIs3nMHr/zvVave9lF+GDE05HB1kuK1vUJ3nDKjO3ny+47xZoKN2UiDCx7XV2kJE9oHBDl0XimvNzxId4oEAtVOD5/cIdDfLEPxxPAOaskqzcxasPY4Xfz4uzety9aibB2PD8MK4HgCAdUeu2N0oreV7U6Ws1s8Jl3E6o+7uvOY6nGasvekT4gEnx7qzYTGdvQEA5ZU18yE5Ozrg4bhwLrZJRBYY7JDdOJdVhPf/SrKYeE4IIf0oh3g64517+zbpfl/8PQY/zopDiKczqgwCSZk1hch6g8DWM9nSdo8Ad3Txs1xvafrgCLg7KXClsAz7U/ItjndEe5JzkZpbgl8T0832L9lw5prv/em2ZMz74SiAmuxNXW4I9TTLxP3r/n44/eY4PDe2xzW3gYjsD4MdshtPr07Ex1uTMXdVgtn+K4VlKCqvgqODDNueG4GeTVynyN/dCYMivNEtwBjEJKQV4Knvj+DXxCs4lW6exbjjhuA67+Hk6ICJ1csIrDtyublfyeYkXirElP/ux4j3tuN0hhYKuQy/zh0MRwcZdpzNwdqEln/H8ko9Ptx8VtoeEO5d77nOSgfce6NxAj9HBxlu6sIVxYmofgx2yGYJIRB/Ps+sC6ohp6q7UbYn5Zgt92BaoyjSzw1KRfP/yncPMM6TsmTDGfzvaDqeXp2IHWeNWR0PZ0c8PiISM4ZE1Hv93f1DAAAbjmeivFJf73kdwW9HzbM5Q7v5ol+oJ2YPjwQAvPjzMRy9VIgJ/96F+T8mNuveG05koFJv7OqbNawLbolqeMj+4nuisfLRWHz/2E0Wq5sTEdXGYIds1n93pWDyf/bhrd9PoaKq8bWqOnnV/OCZVp5Ozi7CS9VDzYd192tRO7r5W3ZPfbzVWHD88oQovDAuqt7aEgAYGO6NEE9nFOmqsOlUVr3nncnU4tv4VJuu7dlxNsds+/mxxsn75o3ujkHh3qjUC9z56R6cytBibcIVxNdaisOkSm+ArkqP9ccycKC6a++vk5l44Sfjn9OTt3TFggk9Gx2uL5fLMLirb4MZICIigEPPycZU6g2Y891hqJ0dsTbhCgDj7MarD17CtzMGYWi3+gMWba0C4r9OZiI6xAO3/msnhADkMuDvN3VuUZtMmZ3adFUGRId44N6Y0DquMCeXy3B3/xB8si0Z645cwe39LLu8MjXlGPfhLgCAn7sK4/rUPQqptZRWVOFgagF83ZToHdy05Qwu5pUgObsYADAhOhB33hCCXsHGLkG5XIbJsaE4kGpel/SvzWdxU5ebpIkZv913Ef/adBb5JRXSOfsWjMLL606gUi8wuqe/lCUiImotzOyQTTl+RYPNp7OlQKe2L3deqPe6Sr0B2vKa7q7Np7Nw+GKBtNTAY0O7ILSFq2D3CHSHr5sKni7m88g8GBtmMQdMfe6+0diVteNsDrKLyi2Ov/l7zdDtHWeNszun5ZVCU1ppcS5g7OJr6XIUBoPAzG8OY+rXBzDxo904Vr1gZWM2nzZ23cV18cFnU2Iwtneg2fGxvQPhVf2MJkQHQukgx4GUfCm78+m2ZLz6ywmzQAcAblq8BbnFOkT6ueLTKTfCVcV/gxFR6+L/VcimNDR8Wd3ApHUFpTU/oO5OChSUVmL5XuPcOPfFdMKCCT1b3CYnRwdsf34EFHIZ5v+YiD+OGxegvDmy6UWxkX5uiOnshcMXC7ByXxrm3dpdOnYpvxQbaq3i/efJTGRry7HlTDbkMmOh7tS4cGQXlePdP5Pw+UMx+Gx7MjI15fjtySHNmswvS1uOp1cfkZZWAICU3JIGZ4g22XLa2AVX32riLkoF1j0+GKUVevQKVuO1X09gRfxF/GvzWbiqFPhX9WKew7r7YedV3WHOjg748P7+XFqBiNoEMztkU87UWnzzhXE9pIn5ACCnWFfvdaZsgZeLozQR3cFU4/IBUU0cfdUQN5UCTo4OZutkhTUzU/TI4HAAwIr4VBy+WCDtX3UgDQYB9OvkAbnM+F22VA9rNwjgQEo+Xlp7DIt+O4XSCj0e/voA9l3IR2peqUUNTWNW7rtoFugAQFlFw0XT5ZV6bDuTLQ2dH92z/tXEw31dpa6tx0d2hVIhx8HUAtz56R5UGQTG9g7AN9MH4Z17+2L28Eg4Ocrh66bCf6cOQDRXByeiNsJgh2zGf3ddwLf7LgIAPrz/Bjw+oismDwrFO5OM8+JkaS27f0xMwY63qxL3VA9JNukZ1HqrTj8zqhvUTgq8MK5HowuEXm1c70BEBbqjsLQS05cfRHmlHkIIafXumcMiMb56mHqIpzOm3RwuXVtUXveItNpz/TTFqepg8slbukpBYWkDwU5ReSUmLd2LR5YfhN4gMLpnAMJ9mzZDcYDaCVNiw6Tt0T398c/q4PVvA0Lx0vgo7Hx+JHa9MBKDu/o263sQETUHu7HIJpToqvDW+tPStmkuHJlMhrjq7qIMTTmEEHUGGaZgx8dVhQGdvdAnRI0TV4xdYlGB157ZMekW4I5jr49t0bUKBznWzI7DiHe3I6+kAhtPZCIqyB0X80qhdJBjeA8/TIgOxP/dHQ03lQJymXGdp6dXJ5rdR6mQ47a+QVibcAVrE66gV5Aajw7t0qQ2JGUZn8nNkb7I1hozZWUNDId/Z2MSTlbPKeTjqsSiO3s36zu/OC4KUYHu6B/mVWeht38jM1kTEbUGq2Z2du7cidtvvx3BwcGQyWT45ZdfpGOVlZV48cUXER0dDVdXVwQHB+Phhx9Gerr5PB/h4eGQyWRmryVLlrTzN6FrlZBW063T2ccFXfxqsgf+ahUAoKLKgIJ6CnalbixXR8hkMnz/2E2YNawLXhwXBW9XZRu2vHncnRwxKcaYeXrmh0RpBNbgrj5wUykgk8ng4ewIB7nx7/KdN4RgSK2sx8ZnhuLYa2Pw9qS+CKwOFJZsONOk+XuKdVW4lF8GwFh0bVqY9OoZp2szzRr99qRoxC8YhRDP5s1n4+TogPsHhtUZ6BARtRerBjslJSXo168fPv30U4tjpaWlSEhIwKuvvoqEhASsXbsWSUlJuOOOOyzOfeONN5CRkSG9nnzyyfZoPrWi/dV1JLf1DcJf84aZzbGiUjjApzpgydTU3ZVV041lDIzcnRyxYEJPzBlhe8OY76xjtuWptbqsrtYnxFjL0reTB6IC1XBydICjgxxbnxsOAKgyCDyy7CAOpTa8HMW5LGPg4ueugrerEi7VwU5D3VimrI+/2qlFEzISEdkCq3ZjjR8/HuPHj6/zmIeHBzZt2mS275NPPsGgQYOQlpaGsLCaWgB3d3cEBgZefQvqQPZdMA5PHtrNt84ROYEeTsgrqUCmtgy9gtXQGwT+s+sCuge4oaJKSF1Wvm62k8WpT+9gD/w6dzB+O5qO/+5OwV03BGNEj/pnC344rjPO5xRj9nDzrioXpUIa2RR/IQ/3fh6P1CUT672PaTh/VKB79fXG59xQgXJphTHr49zApIlERLauQ9XsaDQayGQyeHp6mu1fsmQJ3nzzTYSFheHBBx/EvHnzoFDU/9V0Oh10upqRPVpt66zWTC2TlleKQxcLIJOh3kLVQLUTTqZrkakx/rmt3H+xzoUnYxpYPNKW9Av1RL9QTzwyJAIB7qoGzw32dMZ/Hh5Q57HoELXZMO7ySn2dszkfSSuQir9N9T3OSuN/I6UNdIGZVhVnsENEHVmHCXbKy8vx4osvYvLkyVCrawpOn3rqKdx4443w9vbG3r17sWDBAmRkZOCDDz6o916LFy/GokWL2qPZ1ASrD6YBAIZ09UUnr7qHcwd6GOtTMjVlKCipwPt/na3zvI62IGRza2Cu1vWqpSxOpmsQ07lm+QSDQeD//jiN/+42zjl05w3BGF69bIarqRurgZodUzeWqb6HiKgj6hDBTmVlJf72t79BCIGlS5eaHZs/f770vm/fvlAqlZg1axYWL14MlarufzEvWLDA7DqtVovQ0Man/ae2EV/dhXVP9SzDdTEV42Zqy/HBprPQlFkWKnfzd2twjSp7NLZ3IIZ3T5fm2zl6yTzYSUgrkAIdALjrhppn7NyUmp3qY8zsEFFHZvMVh6ZA5+LFi9i0aZNZVqcusbGxqKqqQmpqar3nqFQqqNVqsxdZT3qhcYRQF1/LBTdNTJmdpMwifH/AmAnqF+opHb+nfwg+frB/2zXSRrkoFVgxfRDmV8/IvGxvClbsTcXB6mLl34/VzMzs6eJo1k3o0kg3lhCCmR0isgs2ndkxBTrnzp3Dtm3b4OPTeBdFYmIi5HI5/P3rL/gk21GpNyC7yFiHE+RZ/5wrQR7G7p6jlzUAgB4B7vjvwwOM6zv1DcLckV3bvrE27I5+wfhkazIu5Zfhtf+dBAA8P7YH/nfUOFXD2N4BeHRoF7MRVTUFynV3Y5nqdQBmdoioY7NqsFNcXIzk5GRpOyUlBYmJifD29kZQUBDuvfdeJCQk4Pfff4der0dmpnFNIm9vbyiVSsTHx2P//v0YOXIk3N3dER8fj3nz5uGhhx6Cl1fHKFS93mUX6SAE4Oggg69r/YW6gR7mx8b0DoCfuwp/PD20rZvYIYT7umLerd3x9saaou13/0wCAHTxc8XHk2+0GDre2NDz2pMNXm/dg0RkX6wa7Bw6dAgjR46Utk11NFOnTsXrr7+O//3vfwCAG264wey6bdu2YcSIEVCpVFi9ejVef/116HQ6REREYN68eWb1OGTbMqq7sALUTpA3sIJ4oId5Ie+YXpxq4GpzRkTi7v4hcFU5YMjb26Apq0SvIDWWTx9Y5xw5UjdWI8GOUiFv8uruRES2yKrBzogRIyCEqPd4Q8cA4MYbb8S+fftau1nUjtKrJwkM9mh4VJKbquavqqODDH1CWGdVF1Nt038eHoDdybl4dGhEvavF12R26u7GYnEyEdkLm67ZIfuXqTFmdhqq17na328Kb/YinNebQRHeGBTh3eA5pqLj8koDDAZhkVkzLUHBYIeIOjoGO9Tuyir0WLLhNIZ288N7fxrnywlqJLMDAMumDcSuc7l4YVyPtm7idcGl1girsko9XFXm/zswdW+5cCQWEXVwDHao3X0Tn4oV8RexIv6itO/qyfHqMjLKHyOjOMqutTgpHCCTAUIYA5urgx1TzQ6Lk4moo7P5eXbI/pRcVRA77eZw3FXH4pjUtuRymdRFdcv723HXp3tQpa8Zbi7V7DCzQ0QdHIMdandXV9u8MrEnFA78q2gNpi6qovIqJF4qxLYk83W2ANbsEFHHx18Yanfa8pqlHmYN78JAx4qurpVatb+ma5HdWERkL/grQ+1OW2Yc6nxP/xA8N4bFxtb01l190NmnZvHVbUk52JOcC4AFykRkPxjsULszZXYGhHvDkVkdq+oX6okdz49E8j/HY2pcZwDAO9UzL7Mbi4jsBX9pqN1pq1csVztzMKCtUDjIMXtEJADg+OVClFZUsUCZiOxGi4KdsrIylJaWStsXL17Ehx9+iL/++qvVGkb2S1tu7Maqb2Zfso4gD2cEeTjBIIBjlzWs2SEiu9GiYOfOO+/EN998AwAoLCxEbGws3n//fdx5551YunRpqzaQ7E9NZofBjq3pH+YJAEhIK5D+nNiNRUQdXYuCnYSEBAwdalxt+qeffkJAQAAuXryIb775Bh999FGrNpDsj6lmR+3Ebixbc0OoJwDgnY1JWHP4MgB2NxJRx9eiYKe0tBTu7u4AgL/++gv33HMP5HI5brrpJly8eLGRq+l6tfVMFnaczUGxrrobi5kdm3N3/04I864ZnRUV6I67+4dYsUVERNeuRf9k69q1K3755Rfcfffd+PPPPzFv3jwAQHZ2NtRqrkZNli7ll2L68kNm+9yZ2bE5fu4qbJ4/HPtT8gAYFxRVKdiNRUQdW4syOwsXLsRzzz2H8PBwxMbGIi4uDoAxy9O/f/9WbSDZh/XHM8y2VQo5f0RtlFIhx9BufhjazY9/RkRkF1r0T+t7770XQ4YMQUZGBvr16yftHzVqFO6+++5WaxzZj9+PpZttV9Zag4mIiKgttbgfITAwEIGBgWb7Bg0adM0NIvuz/0IeTlzRmu3zdlVZqTVERHS9aVGwU1JSgiVLlmDLli3Izs6GwWD+r/QLFy60SuOo48vQlOGN308BAKbEhmHGkAgs/PUkxvYJbORKIiKi1tGiYOfRRx/Fjh078Pe//x1BQUGQya5ex5rI6NVfTuBkuhYuSgfMHh6JUG8XfPdorLWbRURE15EWBTsbNmzA+vXrMXjw4NZuD9mZk+nG7qv37+uH0FpDmomIiNpLi0ZjeXl5wdvbu7XbQnamSm9AlrYcABDT2cvKrSEioutVi4KdN998EwsXLjRbH4voallFOhgE4Oggg68bC5KJiMg6WtSN9f777+P8+fMICAhAeHg4HB3NZ8JNSEholcZRx1RQUoFle1PR1d8NABDo4QS5nHVdRERkHS0Kdu66665WbgbZk2/iL+KjLeegVBgTh0EezlZuERERXc+aHexUVVVBJpNh+vTp6NSpU1u0iTq45JxiAEBFlXFKghBPBjtERGQ9za7ZUSgUePfdd1FVVdUW7SE7kJZXYrYd5OFkpZYQERG1sED5lltuwY4dO1q7LWQnLuYbC9dNC32G+7haszlERHSda1HNzvjx4/HSSy/h+PHjiImJgaur+Y/ZHXfc0SqNo45HU1aJwtJKAMD3j92E7UnZuOOGYCu3ioiIrmctCnYef/xxAMAHH3xgcUwmk0Gv119bq6jDSsszZnV83ZToE+KBPiEeVm4RERFd71oU7Fy9FhaRSVp1F1YYZ0smIiIb0aKaHaL6ZGjKAADBHIFFREQ2okWZnTfeeKPB4wsXLmxRY6jjyy+pAADOmExERDajRcHOunXrzLYrKyuRkpIChUKByMhIBjvXMVOw4+2qtHJLiIiIjFoU7Bw5csRin1arxbRp03D33Xdfc6Oo48pjsENERDam1Wp21Go1Fi1ahFdffbW1bkkdkCmz48Ngh4iIbESrFihrNBpoNJomn79z507cfvvtCA4Ohkwmwy+//GJ2XAiBhQsXIigoCM7Ozhg9ejTOnTtndk5+fj6mTJkCtVoNT09PzJgxA8XFxa3xdagF2I1FRES2pkXdWB999JHZthACGRkZ+PbbbzF+/Pgm36ekpAT9+vXD9OnTcc8991gcf+edd/DRRx9hxYoViIiIwKuvvoqxY8fi1KlTcHIyLkEwZcoUZGRkYNOmTaisrMQjjzyCmTNnYtWqVS35anSN8op1AAAfFigTEZGNkAkhRHMvioiIMNuWy+Xw8/PDLbfcggULFsDd3b35DZHJsG7dOmlFdSEEgoOD8eyzz+K5554DYMwcBQQEYPny5XjggQdw+vRp9OrVCwcPHsSAAQMAABs3bsSECRNw+fJlBAc3beZerVYLDw8PaDQaqNXqZredjCr1BnT7xwYAwJFXb4UXsztERNSGmvr73aLMTkpKSosb1pzPyMzMxOjRo6V9Hh4eiI2NRXx8PB544AHEx8fD09NTCnQAYPTo0ZDL5di/fz+LpdtZQXUXloNcBg9nRyu3hoiIyKhFNTvTp09HUVGRxf6SkhJMnz79mhsFAJmZmQCAgIAAs/0BAQHSsczMTPj7+5sdVygU8Pb2ls6pi06ng1arNXvRtTONxPJycYRcLrNya4iIiIxaFOysWLECZWVlFvvLysrwzTffXHOj2trixYvh4eEhvUJDQ63dJLvA4mQiIrJFzQp2tFotNBoNhBAoKioyy4wUFBTgjz/+sMi0tFRgYCAAICsry2x/VlaWdCwwMBDZ2dlmx6uqqpCfny+dU5cFCxZII8c0Gg0uXbrUKm2+3uVWFycz2CEiIlvSrJodT09PyGQyyGQydO/e3eK4TCbDokWLWqVhERERCAwMxJYtW3DDDTcAMAZb+/fvx5w5cwAAcXFxKCwsxOHDhxETEwMA2Lp1KwwGA2JjY+u9t0qlgkrF0UKtrWaOHT5bIiKyHc0KdrZt2wYhBG655Rb8/PPP8Pb2lo4plUp07ty5ySOgAKC4uBjJycnSdkpKChITE+Ht7Y2wsDA888wzeOutt9CtWzdp6HlwcLA0Yqtnz54YN24cHnvsMXz++eeorKzEE088gQceeKBZ7aDWwW4sIiKyRc0KdoYPHw7AGJSEhYVBJru2ItRDhw5h5MiR0vb8+fMBAFOnTsXy5cvxwgsvoKSkBDNnzkRhYSGGDBmCjRs3SnPsAMDKlSvxxBNPYNSoUZDL5Zg0aZLFPEDUPrhUBBER2aIWzbMDALt27cIXX3yBCxcuYM2aNQgJCcG3336LiIgIDBkypLXb2aY4z07rmP3tYWw8mYk37uyNh+PCrd0cIiKyc039/W7RaKyff/4ZY8eOhbOzMxISEqDTGQtTNRoN/u///q9lLaYOj91YRERki1oU7Lz11lv4/PPP8Z///AeOjjWTxw0ePBgJCQmt1jjqWPJKOBqLiIhsT4uCnaSkJAwbNsxiv4eHBwoLC6+1TdRBmTI7vlwXi4iIbEiLgp3AwECzUVQmu3fvRpcuXa65UdTx6A0ChWWVAJjZISIi29KiYOexxx7D008/jf3790MmkyE9PR0rV67Es88+K82BQ9cPvUFg8n/2wVTq7uXCYIeIiGxHixYCfemll2AwGDBq1CiUlpZi2LBhUKlUeP755/Hoo4+2dhvJxp3LLsKBlHxp24HrYhERkQ1pUWZHJpPhH//4B/Lz83HixAns27cPOTk58PDwQERERGu3kWxcSk6J9P7+AVxnjIiIbEuzgh2dTocFCxZgwIABGDx4MP744w/06tULJ0+eRI8ePfDvf/8b8+bNa6u2ko26kGsMdu66IRhv39vXyq0hIiIy16xgZ+HChVi6dCnCw8ORkpKC++67DzNnzsS//vUvvP/++0hJScGLL77YVm2lNnTsciFueW87/jqZ2exrL1RndiL93Fq7WURERNesWTU7a9aswTfffIM77rgDJ06cQN++fVFVVYWjR49e89IRZF1zvkvAlcIyzPz2MFKXTGzWtRdyiwEAXRjsEBGRDWpWZufy5cvS6uJ9+vSBSqXCvHnzGOjYOINB4FxWEQwGy5VBhBAQQqCgtKLF90+p7saK8HVt8T2IiIjaSrMyO3q9HkplzbBihUIBNzf+a97WfbHzAt7eeAYPxoZhcKQvxvYOgMJBjk+3JeOLHecxtJsfWrZCGqAtr0RhqXF+nXBfl1ZsNRERUetoVrAjhMC0adOgUhlnyC0vL8fs2bPh6mr+L/q1a9e2Xgvpmr298QwAYNX+NKzan4aXJ0Th3phQvPtnEgBg0+kstHS0eJamHACgdlLARdmimQyIiIjaVLN+naZOnWq2/dBDD7VqY6h9rD5wCaN7BkjbBoOArIXRTqbWGOwEeji1StuIiIhaW7OCnWXLlrVVO6gd5ZdWoFhXJW1XGQT0LezHyqzO7ASoGewQEZFtatGkgtRxlFfqLfYVllaiqLzKbF9La3ayqjM7QczsEBGRjWKwY+cu5ZfWub+ovLJV7p9RndkJZGaHiIhsFIMdO3cxr+5gJ62eIAgwFqI3lSmzE8DMDhER2SgGO3YuXVNW5/7jV7T1XqOrMjT5/lKBMjM7RERkoxjs2Lmra3NM9ibn1ntNWYVlnU99srQ6ACxQJiIi28Vgx85p66nNySupf8bk0jqKmuujKTPe38tV2ciZRERE1sFgx84V15PZaUiprmnXlFfqUVHd5eXuxAkFiYjINjHYsXN1dWM5OTb8x17axG4s071lMsCNsycTEZGNYrBj54qvytI4OsjQI8C9wWuaHuwYu7DcVArIW7reBBERURtjsGPnrp5PRwYZIv1qFm/1dVNZXFNW2bRuLG11Zkft5HgNLSQiImpbDHbsnEU3lgyI9K8JdgI9LIOdEl3zMjus1yEiIlvGYMfOXR3s3BYdhEi/mlXqA9wth4w3deh5ETM7RETUAfCf5HbOVLOz6rFYJGcX4+7+IdISDwDgX8f8OKUVTezGKmNmh4iIbB9/peyYEEIKdrr4uuHmSF8AgFJRk9CrawHPkmZmdhjsEBGRLeOvlB0rq9RDbzCuc1U7IFEpHPDl32OgKauEo0NN4NPV3w3J2cUWI7jqY6rZUTuzG4uIiGwXa3bsmCnzIpcBLkoHs2NjegfivgGhqNTXrIN1e99gAEB29RIQjdEys0NERB0Af6XsWO15cGSyuufBua1vMP48mYlRPQOgqu7e+jnhMsqr9Fh8T3SDxcdaaTQWMztERGS7GOzYsZqamvqDEWelA/47dSAAYO/5msVB1x/LQHd/dzw9ulu912rLmNkhIiLbx24sO9bcAuIgD+errq97EdGrj3PoORER2TIGO3asucFO4FXD0N0auY41O0RE1BEw2LFjhWUVAAAPZ2WTzne+qohZU9ZwZiev2FjIXNeSE0RERLbC5oOd8PBwyGQyi9fcuXMBACNGjLA4Nnv2bCu32jYUlhqDFU+XlnUzaUrrD3b0BoHc6mDH353BDhER2S6b7384ePAg9PqaSe5OnDiBW2+9Fffdd5+077HHHsMbb7whbbu4uLRrG22VKTPj2cJ5cApKK+o9lleig0EAMhng7dq0zBEREZE12Hyw4+fnZ7a9ZMkSREZGYvjw4dI+FxcXBAYGtnfTbF5hdbDi1YxgZOmUGzFnZQIAoKCBzI5pLh4fVxUUDjafICQioutYh/qVqqiowHfffYfp06ebzRuzcuVK+Pr6ok+fPliwYAFKS0sbvI9Op4NWqzV72SNTN5ZHMzI746ODsGZ2HICGa3ZyitiFRUREHYPNZ3Zq++WXX1BYWIhp06ZJ+x588EF07twZwcHBOHbsGF588UUkJSVh7dq19d5n8eLFWLRoUTu02LoKy1pWs2Pq9mqoG0sKdtQMdoiIyLZ1qGDnq6++wvjx4xEcHCztmzlzpvQ+OjoaQUFBGDVqFM6fP4/IyMg677NgwQLMnz9f2tZqtQgNDW27hluJqcDYs4mjsUw8XYzna8oqoTcIOMgtZ1/OLjKunM7MDhER2boOE+xcvHgRmzdvbjBjAwCxsbEAgOTk5HqDHZVKBZXK/n+kTUPPm5vZMXV7CWGcONAU/NSWLXVjWa6aTkREZEs6TM3OsmXL4O/vj4kTJzZ4XmJiIgAgKCioHVpl21pSswMASoUcbipjHFxfkbKpQNmPmR0iIrJxHSKzYzAYsGzZMkydOhUKRU2Tz58/j1WrVmHChAnw8fHBsWPHMG/ePAwbNgx9+/a1Youtr7xSD12VcUXzlsyz4+niiGJdFfJLdIjwdbU4rmlhPRAREVF76xCZnc2bNyMtLQ3Tp083269UKrF582aMGTMGUVFRePbZZzFp0iT89ttvVmqp7TBldRzkMilL0xwhnsZ1stLy6x7ZVl5lnPvIydGhzuNERES2okNkdsaMGQMhhMX+0NBQ7Nixwwotsn1SvY6zo9kw/aaK8HXF/pR8pOTWE+xUGrNGDHaIiMjWdYjMDjVfUmYRACDIs2UFxKauq9TckjqP6yqrMzsK/hUiIiLbxl8qO7XrXC4AYHCkb4uuDzcFO3l1BzvllezGIiKijoHBjh0SQmDXuRwAwNBufo2cXTdTZiclp6TOLsTyKnZjERFRx8Bgxw5laMqRpdVBIZdhQLhXi+4R5u0CmQwo0lUhr8RyJuWazA7/ChERkW3jL5Udqj0svKWZFydHB6idjMPKC69aNkIIwW4sIiLqMBjs2KFiXRUAtGjIeW0uSmMgU1qhN9tfqRcwVPdsOSkY7BARkW1jsGOHisurgx2nawt2nKuDnRKdebBjmmMHAFTsxiIiIhvXIebZoeYpauXMTllllbQvp0gHAWNaRyYDVBx6TkRENo7Bjh2SMjuqa1vKwUVp/Oth6sbalpSNR5YdRLiPCwBjF1ZLJiwkIiJqT/xnuR0qqc7suF9jN9bVNTun0rUAgNQ846zKHIlFREQdAX+t7FCrd2NVBzumIMqEI7GIiKgjYLBjh1qtQNnRvBuLwQ4REXVEDHbsULHOOM9O6w09NwY5RVcFOyxOJiKijoC/VnaouLVqdlTmNTvM7BARUUfEYMcOFZW3Us2ORTeW+Xw7LFAmIqKOgL9Wdqi1Z1Auq+7GKmZmh4iIOiAGO3aotWdQrq8bS845doiIqANgsGOHpJqda55U0DSDct3Bjq5Kb3ENERGRrWGwY4daK7NjmkF517lc/HE8w6Ibq7zScE33JyIiag9cLsLOGAwCxRWtW7MDAI+vTID8ql6r8kpmdoiIyPYxs2NntOWVEMZ1OqF2br1gBwAMwvy4roqZHSIisn0MduxMXkkFAMBdpYBKcW2jpZyVDV/PzA4REXUEDHbsTF6xMdjxcVNe871MNTu1udYKgMJ9XK/5M4iIiNoagx07k1+iAwB4u157sONaR2bHVaXAusdvxm19g/D2vX2v+TOIiIjaGguU7UyulNlRXfO9XOsocHZTKdA/zAufPOh1zfcnIiJqD8zs2Jn86podn9bI7KgUeOfevhgU4W22j4iIqCNhsGNn8oqN3VitUbMDAH8bEIpnRneTtv3crz1jRERE1J74z3Q7YxqN5e3aekFJbIQP5oyIREWVAQ/HdW61+xIREbUHBjt2xjQay7eVMjsA4CCX4cVxUa12PyIiovbEbiw7ky9ldlov2CEiIurIGOzYmTwGO0RERGYY7NiZklZa8ZyIiMheMNixI0IIlFcZl3BwcuQfLREREcBgx65U6A3SIqAqx2tbF4uIiMheMNixI+WVNauQM7NDRERkZNO/iK+//jpkMpnZKyqqZgh0eXk55s6dCx8fH7i5uWHSpEnIysqyYoutS1e9CrlMBigdbPqPloiIqN3Y/C9i7969kZGRIb12794tHZs3bx5+++03rFmzBjt27EB6ejruueceK7bWukyZHSeFA2QymZVbQ0REZBtsflJBhUKBwMBAi/0ajQZfffUVVq1ahVtuuQUAsGzZMvTs2RP79u3DTTfd1N5NtToWJxMREVmy+V/Fc+fOITg4GF26dMGUKVOQlpYGADh8+DAqKysxevRo6dyoqCiEhYUhPj7eWs21qvJKU7DD4mQiIiITm87sxMbGYvny5ejRowcyMjKwaNEiDB06FCdOnEBmZiaUSiU8PT3NrgkICEBmZmaD99XpdNDpdNK2Vqtti+a3O6kbi8EOERGRxKaDnfHjx0vv+/bti9jYWHTu3Bk//vgjnJ2dW3zfxYsXY9GiRa3RRJuiq+7GUilsPmFHRETUbjrUr6Knpye6d++O5ORkBAYGoqKiAoWFhWbnZGVl1VnjU9uCBQug0Wik16VLl9qw1e2HmR0iIiJLHSrYKS4uxvnz5xEUFISYmBg4Ojpiy5Yt0vGkpCSkpaUhLi6uwfuoVCqo1Wqzlz2oqdnpUH+sREREbcqmu7Gee+453H777ejcuTPS09Px2muvwcHBAZMnT4aHhwdmzJiB+fPnw9vbG2q1Gk8++STi4uKuy5FYAAuUiYiI6mLTwc7ly5cxefJk5OXlwc/PD0OGDMG+ffvg5+cHAPjXv/4FuVyOSZMmQafTYezYsfjss8+s3GrrKa+qmWeHiIiIjGw62Fm9enWDx52cnPDpp5/i008/bacW2TYdu7GIiIgs8FfRjrAbi4iIyBKDHTvC0VhERESWGOzYEVNmR8VuLCIiIgl/Fe2ItDYWC5SJiIgkDHbsiKkbi5kdIiKiGvxVtCNSgTIzO0RERBIGO3aEBcpERESWGOzYEdNCoJxnh4iIqAZ/Fe0I59khIiKyxGDHjtR0Y/GPlYiIyIS/inakRFcFgJkdIiKi2hjs2AldlR5p+aUAgHAfVyu3hoiIyHYw2LETydnFqDIIeDg7IsjDydrNISIishkMduzE6YwiAEBUoDtkMpmVW0NERGQ7GOzYiTMZWgBAzyC1lVtCRERkWxjs2ImkLGNmp2eQu5VbQkREZFsY7NiJywVlAIDOLE4mIiIyw2DHDhgMAlcKjcFOiKezlVtDRERkWxjs2IHcEh0qqgyQy4BAjsQiIiIyw2DHDpi6sALVTnB04B8pERFRbfxltANXqoOdEC92YREREV2NwY4dYL0OERFR/Rjs2AFmdoiIiOrHYMcO5BbrAAD+7ixOJiIiuhqDHTtQWFoJAPB0cbRyS4iIiGwPgx07oCkzBjsezgx2iIiIrsZgxw6Ygh1PF6WVW0JERGR7GOzYAWZ2iIiI6sdgp4Or1BtQrKsCAHgy2CEiIrLAYMdGHbtciFve244/T2Y2eJ62OqsDAGoGO0RERBYY7NiotzeewYXcEsz69jB0Vfp6zyusDnbcnRRwkMvaq3lEREQdBoMdG5VbVCG97/HKRiSkFdR5Hut1iIiIGsZgxwZV6g1IySsx2/fHsQzp/Z7kXCRlFgEANJxjh4iIqEEMdmzQuaxiVFQZ4KZS4KlbugIAjlwqBACcydRiyn/3Y+yHOwEws0NERNQYBjs2IqdIh/s+34tHVxzCgZQ8AEDvYDXuvrETAOD4FQ3OZRXhy50XpGvKKvQoLDV2d3k6c44dIiKiuiis3QAyemJVAg6mGutydp7LAQAM7eaLcB8XeLo4orC0Erf+a6fZNZnacuSVGIMdjsQiIiKqm01ndhYvXoyBAwfC3d0d/v7+uOuuu5CUlGR2zogRIyCTycxes2fPtlKLW0ZTWon9KfnSdkWVAQAwpncgZDIZxvcJrPO6bWeypUxPF1/Xtm8oERFRB2TTwc6OHTswd+5c7Nu3D5s2bUJlZSXGjBmDkhLz4t3HHnsMGRkZ0uudd96xUotb5lJBKQDA102JaTeHAwAifF3Rzd8NALDojj54fmwPhHg6m123fG8qdFUGxHT2wt/jOrdrm4mIiDoKm+7G2rhxo9n28uXL4e/vj8OHD2PYsGHSfhcXFwQG1p396AguVwc7IV4uWDAhCsGeToiN8IFMZpw3R6mQY+7Irnh8RCSWbDiDL6qzOWn5xusGd/WFk6ODdRpPRERk42w6s3M1jUYDAPD29jbbv3LlSvj6+qJPnz5YsGABSktLG7yPTqeDVqs1e1nTpfwyAEColzNUCgfMHBaJfqGeFufJZDIsmNBTGqFlEqBWtUcziYiIOiSbzuzUZjAY8Mwzz2Dw4MHo06ePtP/BBx9E586dERwcjGPHjuHFF19EUlIS1q5dW++9Fi9ejEWLFrVHs5vE1I0V6u3SpPODrurOCnB3avU2ERER2YsOE+zMnTsXJ06cwO7du832z5w5U3ofHR2NoKAgjBo1CufPn0dkZGSd91qwYAHmz58vbWu1WoSGhrZNw5vgUnV3VKhXE4MdD/PgJkDNYIeIiKg+HSLYeeKJJ/D7779j586d6NSpU4PnxsbGAgCSk5PrDXZUKhVUKtvp+rlUUN2N5e3cyJlGPQLdzbbZjUVERFQ/mw52hBB48sknsW7dOmzfvh0RERGNXpOYmAgACAoKauPWtY6KKgMuVi8NEe7TtOHjgVdlcnzcGOwQERHVx6aDnblz52LVqlX49ddf4e7ujszMTACAh4cHnJ2dcf78eaxatQoTJkyAj48Pjh07hnnz5mHYsGHo27evlVvfNOeyi1CpF1A7KdDJq2mZHZlMhgC1CllaHQBwtXMiIqIG2PRorKVLl0Kj0WDEiBEICgqSXj/88AMAQKlUYvPmzRgzZgyioqLw7LPPYtKkSfjtt9+s3PKmO5VuHAnWK1gtDTVvis7enESQiIioKWw6syOEaPB4aGgoduzY0U6taRsnTcFOkEezrnvzrj64+7M9eHRol7ZoFhERkd2w6WDnenDiinHuoN7B6mZd1yPQHcdeGwOFg00n54iIiKyOv5RWlFOkQ0KacfHPQRHejZxtiYEOERFR45jZsYKyCj02nsxAblEFDALo18mjyRMKEhERUfMw2LGCT7adw6fbzkvbE/t2jGHyREREHRH7Qazg+wOXzLYnRDPYISIiaisMdtrQk98fwa0f7EBanvnCpCFXrW3VqYnLRBAREVHzMdhpQ2czi3Auuxjnc4vN9qcXlknv/3l3n6svIyIiolbEYKcNhfsaMzapuSXSvmJdFfJKKgAAKx+NxYODwqzSNiIiousFC5TbULivcZbj2sGOaYVzLxdHDO7qa5V2ERERXU+Y2WlDXaqDnRXxF3HnJ7tRUWVAWnWwE8ah5kRERO2CwU4bqr2K+dHLGmxPysYvR64AALr4uVmrWURERNcVdmO1oQhf88U6n/3xKIp0VXCQy/AY17QiIiJqF8zstCE/d5XZdpGuCgDw4KAw9GrmWlhERETUMszstCGZTIa1j9+M/OIK/JxwGRtOZAIApg+JsHLLiIiIrh8MdtrYjWFeAIDoTh64mFeKuEgfi+4tIiIiajsMdtpJgNoJfzw91NrNICIiuu6wZoeIiIjsGoMdIiIismsMdoiIiMiuMdghIiIiu8Zgh4iIiOwagx0iIiKyawx2iIiIyK4x2CEiIiK7xmCHiIiI7BqDHSIiIrJrDHaIiIjIrjHYISIiIrvGYIeIiIjsGoMdIiIismsKazfAFgghAABardbKLSEiIqKmMv1um37H68NgB0BRUREAIDQ01MotISIiouYqKiqCh4dHvcdlorFw6DpgMBiQnp4Od3d3yGSyVruvVqtFaGgoLl26BLVa3Wr3JUt81u2Dz7l98Dm3Hz7r9tFWz1kIgaKiIgQHB0Mur78yh5kdAHK5HJ06dWqz+6vVav5H1E74rNsHn3P74HNuP3zW7aMtnnNDGR0TFigTERGRXWOwQ0RERHaNwU4bUqlUeO2116BSqazdFLvHZ90++JzbB59z++Gzbh/Wfs4sUCYiIiK7xswOERER2TUGO0RERGTXGOwQERGRXWOwQ0RERHaNwU4b+vTTTxEeHg4nJyfExsbiwIED1m5Sh7Jz507cfvvtCA4Ohkwmwy+//GJ2XAiBhQsXIigoCM7Ozhg9ejTOnTtndk5+fj6mTJkCtVoNT09PzJgxA8XFxe34LWzf4sWLMXDgQLi7u8Pf3x933XUXkpKSzM4pLy/H3Llz4ePjAzc3N0yaNAlZWVlm56SlpWHixIlwcXGBv78/nn/+eVRVVbXnV7FpS5cuRd++faVJ1eLi4rBhwwbpOJ9x21iyZAlkMhmeeeYZaR+fdet4/fXXIZPJzF5RUVHScZt6zoLaxOrVq4VSqRRff/21OHnypHjssceEp6enyMrKsnbTOow//vhD/OMf/xBr164VAMS6devMji9ZskR4eHiIX375RRw9elTccccdIiIiQpSVlUnnjBs3TvTr10/s27dP7Nq1S3Tt2lVMnjy5nb+JbRs7dqxYtmyZOHHihEhMTBQTJkwQYWFhori4WDpn9uzZIjQ0VGzZskUcOnRI3HTTTeLmm2+WjldVVYk+ffqI0aNHiyNHjog//vhD+Pr6igULFljjK9mk//3vf2L9+vXi7NmzIikpSbz88svC0dFRnDhxQgjBZ9wWDhw4IMLDw0Xfvn3F008/Le3ns24dr732mujdu7fIyMiQXjk5OdJxW3rODHbayKBBg8TcuXOlbb1eL4KDg8XixYut2KqO6+pgx2AwiMDAQPHuu+9K+woLC4VKpRLff/+9EEKIU6dOCQDi4MGD0jkbNmwQMplMXLlypd3a3tFkZ2cLAGLHjh1CCONzdXR0FGvWrJHOOX36tAAg4uPjhRDGwFQul4vMzEzpnKVLlwq1Wi10Ol37foEOxMvLS/z3v//lM24DRUVFolu3bmLTpk1i+PDhUrDDZ916XnvtNdGvX786j9nac2Y3VhuoqKjA4cOHMXr0aGmfXC7H6NGjER8fb8WW2Y+UlBRkZmaaPWMPDw/ExsZKzzg+Ph6enp4YMGCAdM7o0aMhl8uxf//+dm9zR6HRaAAA3t7eAIDDhw+jsrLS7FlHRUUhLCzM7FlHR0cjICBAOmfs2LHQarU4efJkO7a+Y9Dr9Vi9ejVKSkoQFxfHZ9wG5s6di4kTJ5o9U4B/n1vbuXPnEBwcjC5dumDKlClIS0sDYHvPmQuBtoHc3Fzo9XqzP0AACAgIwJkzZ6zUKvuSmZkJAHU+Y9OxzMxM+Pv7mx1XKBTw9vaWziFzBoMBzzzzDAYPHow+ffoAMD5HpVIJT09Ps3OvftZ1/VmYjpHR8ePHERcXh/Lycri5uWHdunXo1asXEhMT+Yxb0erVq5GQkICDBw9aHOPf59YTGxuL5cuXo0ePHsjIyMCiRYswdOhQnDhxwuaeM4MdIpLMnTsXJ06cwO7du63dFLvUo0cPJCYmQqPR4KeffsLUqVOxY8cOazfLrly6dAlPP/00Nm3aBCcnJ2s3x66NHz9eet+3b1/Exsaic+fO+PHHH+Hs7GzFllliN1Yb8PX1hYODg0XVeVZWFgIDA63UKvtieo4NPePAwEBkZ2ebHa+qqkJ+fj7/HOrwxBNP4Pfff8e2bdvQqVMnaX9gYCAqKipQWFhodv7Vz7quPwvTMTJSKpXo2rUrYmJisHjxYvTr1w///ve/+Yxb0eHDh5GdnY0bb7wRCoUCCoUCO3bswEcffQSFQoGAgAA+6zbi6emJ7t27Izk52eb+TjPYaQNKpRIxMTHYsmWLtM9gMGDLli2Ii4uzYsvsR0REBAIDA82esVarxf79+6VnHBcXh8LCQhw+fFg6Z+vWrTAYDIiNjW33NtsqIQSeeOIJrFu3Dlu3bkVERITZ8ZiYGDg6Opo966SkJKSlpZk96+PHj5sFl5s2bYJarUavXr3a54t0QAaDATqdjs+4FY0aNQrHjx9HYmKi9BowYACmTJkiveezbhvFxcU4f/48goKCbO/vdKuWO5Nk9erVQqVSieXLl4tTp06JmTNnCk9PT7Oqc2pYUVGROHLkiDhy5IgAID744ANx5MgRcfHiRSGEcei5p6en+PXXX8WxY8fEnXfeWefQ8/79+4v9+/eL3bt3i27dunHo+VXmzJkjPDw8xPbt282GkJaWlkrnzJ49W4SFhYmtW7eKQ4cOibi4OBEXFycdNw0hHTNmjEhMTBQbN24Ufn5+HKpby0svvSR27NghUlJSxLFjx8RLL70kZDKZ+Ouvv4QQfMZtqfZoLCH4rFvLs88+K7Zv3y5SUlLEnj17xOjRo4Wvr6/Izs4WQtjWc2aw04Y+/vhjERYWJpRKpRg0aJDYt2+ftZvUoWzbtk0AsHhNnTpVCGEcfv7qq6+KgIAAoVKpxKhRo0RSUpLZPfLy8sTkyZOFm5ubUKvV4pFHHhFFRUVW+Da2q65nDEAsW7ZMOqesrEw8/vjjwsvLS7i4uIi7775bZGRkmN0nNTVVjB8/Xjg7OwtfX1/x7LPPisrKynb+NrZr+vTponPnzkKpVAo/Pz8xatQoKdARgs+4LV0d7PBZt477779fBAUFCaVSKUJCQsT9998vkpOTpeO29JxlQgjRurkiIiIiItvBmh0iIiKyawx2iIiIyK4x2CEiIiK7xmCHiIiI7BqDHSIiIrJrDHaIiIjIrjHYISIiIrvGYIeIOozU1FTIZDIkJia22WdMmzYNd911V5vdn4jaH4MdImo306ZNg0wms3iNGzeuSdeHhoYiIyMDffr0aeOWEpE9UVi7AUR0fRk3bhyWLVtmtk+lUjXpWgcHB646TUTNxswOEbUrlUqFwMBAs5eXlxcAQCaTYenSpRg/fjycnZ3RpUsX/PTTT9K1V3djFRQUYMqUKfDz84OzszO6detmFkgdP34ct9xyC5ydneHj44OZM2eiuLhYOq7X6zF//nx4enrCx8cHL7zwAq5eQcdgMGDx4sWIiIiAs7Mz+vXrZ9amxtpARNbHYIeIbMqrr76KSZMm4ejRo5gyZQoeeOABnD59ut5zT506hQ0bNuD06dNYunQpfH19AQAlJSUYO3YsvLy8cPDgQaxZswabN2/GE088IV3//vvvY/ny5fj666+xe/du5OfnY926dWafsXjxYnzzzTf4/PPPcfLkScybNw8PPfQQduzY0WgbiMhGtPrSokRE9Zg6dapwcHAQrq6uZq9//vOfQgjjCuyzZ882uyY2NlbMmTNHCCFESkqKACCOHDkihBDi9ttvF4888kidn/Xll18KLy8vUVxcLO1bv369kMvlIjMzUwghRFBQkHjnnXek45WVlaJTp07izjvvFEIIUV5eLlxcXMTevXvN7j1jxgwxefLkRttARLaBNTtE1K5GjhyJpUuXmu3z9vaW3sfFxZkdi4uLq3f01Zw5czBp0iQkJCRgzJgxuOuuu3DzzTcDAE6fPo1+/frB1dVVOn/w4MEwGAxISkqCk5MTMjIyEBsbKx1XKBQYMGCA1JWVnJyM0tJS3HrrrWafW1FRgf79+zfaBiKyDQx2iKhdubq6omvXrq1yr/Hjx+PixYv4448/sGnTJowaNQpz587Fe++91yr3N9X3rF+/HiEhIWbHTEXVbd0GIrp2rNkhIpuyb98+i+2ePXvWe76fnx+mTp2K7777Dh9++CG+/PJLAEDPnj1x9OhRlJSUSOfu2bMHcrkcPXr0gIeHB4KCgrB//37peFVVFQ4fPixt9+rVCyqVCmlpaejatavZKzQ0tNE2EJFtYGaHiNqVTqdDZmam2T6FQiEV9a5ZswYDBgzAkCFDsHLlShw4cABfffVVnfdauHAhYmJi0Lt3b+h0Ovz+++9SYDRlyhS89tprmDp1Kl5//XXk5OTgySefxN///ncEBAQAAJ5++mksWbIE3bp1Q1RUFD744AMUFhZK93d3d8dzzz2HefPmwWAwYMiQIdBoNNizZw/UajWmTp3aYBuIyDYw2CGidrVx40YEBQWZ7evRowfOnDkDAFi0aBFWr16Nxx9/HEFBQfj+++/Rq1evOu+lVCqxYMECpKamwtnZGUOHDsXq1asBAC4uLvjzzz/x9NNPY+DAgXBxccGkSZPwwQcfSNc/++yzyMjIwNSpUyGXyzF9+nTcfffd0Gg00jlvvvkm/Pz8sHjxYly4cAGenp648cYb8fLLLzfaBiKyDTIhrppUgojISmQyGdatW8flGoioVbFmh4iIiOwagx0iIiKya6zZISKbwV51ImoLzOwQERGRXWOwQ0RERHaNwQ4RERHZNQY7REREZNcY7BAREZFdY7BDREREdo3BDhEREdk1BjtERERk1xjsEBERkV37f2dncIDe1o+aAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_episodes = 500\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "lmbda = 0.95\n",
    "critic_lr = 1e-2\n",
    "kl_constraint = 0.0005\n",
    "alpha = 0.5\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "_ = env.reset(seed=0)\n",
    "torch.manual_seed(0)\n",
    "agent = TRPO(hidden_dim, env.observation_space, env.action_space, lmbda,\n",
    "             kl_constraint, alpha, critic_lr, gamma, device)\n",
    "return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "# Iteration 0: 100%|██████████| 50/50 [00:02<00:00, 16.85it/s, episode=50,\n",
    "# return=139.200]\n",
    "# Iteration 1: 100%|██████████| 50/50 [00:03<00:00, 16.55it/s, episode=100,\n",
    "# return=150.500]\n",
    "# Iteration 2: 100%|██████████| 50/50 [00:03<00:00, 14.21it/s, episode=150,\n",
    "# return=184.000]\n",
    "# Iteration 3: 100%|██████████| 50/50 [00:03<00:00, 14.15it/s, episode=200,\n",
    "# return=183.600]\n",
    "# Iteration 4: 100%|██████████| 50/50 [00:03<00:00, 13.96it/s, episode=250,\n",
    "# return=183.500]\n",
    "# Iteration 5: 100%|██████████| 50/50 [00:03<00:00, 13.29it/s, episode=300,\n",
    "# return=193.700]\n",
    "# Iteration 6: 100%|██████████| 50/50 [00:03<00:00, 14.08it/s, episode=350,\n",
    "# return=199.500]\n",
    "# Iteration 7: 100%|██████████| 50/50 [00:03<00:00, 13.36it/s, episode=400,\n",
    "# return=200.000]\n",
    "# Iteration 8: 100%|██████████| 50/50 [00:03<00:00, 13.33it/s, episode=450,\n",
    "# return=200.000]\n",
    "# Iteration 9: 100%|██████████| 50/50 [00:03<00:00, 13.08it/s, episode=500,\n",
    "# return=200.000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "executionInfo": {
     "elapsed": 465,
     "status": "ok",
     "timestamp": 1649956066886,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "PNG1FiQf_SlK"
   },
   "outputs": [],
   "source": [
    "class PolicyNetContinuous(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(PolicyNetContinuous, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc_mu = torch.nn.Linear(hidden_dim, action_dim)  ## 用来求每个动作正态分布的均值\n",
    "        self.fc_std = torch.nn.Linear(hidden_dim, action_dim) ## 用来求每个动作正态分布的方差\n",
    "\n",
    "    ## 要求出摆动作的概率分布，默认是正态分布的\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        mu = 2.0 * torch.tanh(self.fc_mu(x))       ## predict每个动作的正态分布的均值，取值区间则是 [-2, 2]\n",
    "        std = F.softplus(self.fc_std(x))           ## predict每个动作的正态分布的方差，使用了函数 softplus\n",
    "        return mu, std  # 高斯分布的均值和标准差\n",
    "\n",
    "class TRPOContinuous:\n",
    "    \"\"\" 处理连续动作的TRPO算法 \"\"\"\n",
    "    def __init__(self, hidden_dim, state_space, action_space, lmbda,\n",
    "                 kl_constraint, alpha, critic_lr, gamma, device):\n",
    "        ## 状态的dimension，Pendulum-v1是 3 dim，也就是摆末端的(x,y)坐标，和角速度\n",
    "        ## https://gymnasium.farama.org/environments/classic_control/pendulum/\n",
    "        state_dim = state_space.shape[0] ## 3\n",
    "        action_dim = action_space.shape[0]      ## 1 continuous action，只有一个值，也就是给摆末端施加的 力矩\n",
    "        self.actor = PolicyNetContinuous(state_dim, hidden_dim,\n",
    "                                         action_dim).to(device) ##  策略网络不使用传统的 SGD 等梯度下降方式 \n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device)    ##  价值网络仍旧使用SGD ADAM等梯度下降方式 update\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)   ## 价值函数配置优化器\n",
    "        self.gamma = gamma   ## 衰减因子的呢\n",
    "        self.lmbda = lmbda  # GAE参数\n",
    "        self.kl_constraint = kl_constraint  # KL距离最大限制，对策略网络的参数update 做出相应的限制\n",
    "        self.alpha = alpha  # 线性搜索参数\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state): # 根据动作概率分布随机采样\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        mu, std = self.actor(state)      ## 拿到该状态下，均值和标准差\n",
    "        action_dist = torch.distributions.Normal(mu, std)    ##   配置 好采样的概率\n",
    "        action = action_dist.sample()       ## 对该状态下，所有的动作采样，采样的分布是高斯分布\n",
    "        return [action.item()]              ## 返回采样的动作值，也就是力矩的大小\n",
    "\n",
    "    ## old_action_dists 在传入前已经detach了，不需要反向传播求梯度，是KL散度的梯度\n",
    "    def hessian_matrix_vector_product(self,\n",
    "                                      states,\n",
    "                                      old_action_dists,\n",
    "                                      vector,\n",
    "                                      damping=0.1):\n",
    "        # 计算黑塞矩阵和一个向量的乘积\n",
    "        mu, std = self.actor(states) ## 拿到该状态下，均值和标准差 \n",
    "        new_action_dists = torch.distributions.Normal(mu, std)   ##   配置 好采样的概率\n",
    "        ## 策略网络给出选择动作的概率，然后依概率采样\n",
    "        ## 算出旧动作选择概率  和  当前动作选择概率的 KL散度，描述了两者的对齐程度，越相似值越小，差异越大值越大\n",
    "        kl = torch.mean(torch.distributions.kl.kl_divergence(old_action_dists, new_action_dists))\n",
    "        '''\n",
    "        反向求策略网络参数的梯度，这是1阶导数的呢 \n",
    "        https://pytorch.org/docs/stable/generated/torch.autograd.grad.html?highlight=grad#torch.autograd.grad\n",
    "        torch.autograd.grad(output, input, ......)\n",
    "        create_graph=True，产生求梯度的图，允许求更高阶的导数，像二阶导数\n",
    "        kl：kl散度，也就是可导运算的输出，\n",
    "        self.actor.parameters()：策略网络的参数，也就是可导运算的输入，最后会返回该输入的梯度，而且梯度不会累加到参数的.grad变量，会直接返回的\n",
    "        '''\n",
    "        ##  此时反向传播求出的是 self.actor参数的梯度，也就是一阶偏导数，kl_grad: KL ---> new_action_dists ---> self.actor\n",
    "        kl_grad = torch.autograd.grad(kl, self.actor.parameters(), create_graph = True)\n",
    "        kl_grad_vector = torch.cat([grad.view(-1) for grad in kl_grad])   ##  一阶梯度全部列化，并且拼起来的\n",
    "        # KL距离的梯度先和向量进行点积运算\n",
    "        ## 这样就不需要存储二阶偏导数的矩阵了，向量先和一阶偏导数运算，然后再直接求二阶偏导的，此时二阶偏导也是个向量的，而不是矩阵了\n",
    "        kl_grad_vector_product = torch.dot(kl_grad_vector, vector)\n",
    "        '''\n",
    "        求策略网络参数的二阶导数，也就是二阶梯度，此时二阶偏导也是个向量的，而不是矩阵了\n",
    "        grad2:   kl_grad_vector_product--->kl_grad_vector--->KL ---> new_action_dists ---> self.actor\n",
    "        '''\n",
    "        grad2 = torch.autograd.grad(kl_grad_vector_product, self.actor.parameters())\n",
    "        grad2_vector = torch.cat([grad.contiguous().view(-1) for grad in grad2])   ##  二阶梯度全部列化，并且拼起来的\n",
    "        return grad2_vector + damping * vector\n",
    "\n",
    "    ## https://zhuanlan.zhihu.com/p/657548225\n",
    "    ## 参数分别是 （grad：当前策略网络的一阶偏导数，states：当前状态的，old_action_dists：当前策略网络的动作分布）\n",
    "    ## old_action_dists 在传入前已经detach了，不需要反向传播求梯度\n",
    "    ## Hx = g，g=grad是使用策略网络算广义优势估计时的一阶偏导数，H是算KL散度时的二阶偏导数\n",
    "    def conjugate_gradient(self, grad, states, old_action_dists):  # 共轭梯度法求解方程\n",
    "        x = torch.zeros_like(grad)  ##  初始化线性方程组 Hx=g，需要求解的向量x\n",
    "        r = grad.clone()    ##  复制梯度的，初始化一阶偏导的残差，或者说是一阶偏导数\n",
    "        p = grad.clone()    ##  复制梯度的，初始化方向向量的\n",
    "        rdotr = torch.dot(r, r)  ## 初始化 beta 值，用来运算求出 下一个方向向量的，或者用来求出 alpha\n",
    "        for i in range(10):  # 共轭梯度主循环\n",
    "            ## 算出 alpha步长 分母需要的内容，p^THp 内的 Hp，也就是KL散度二阶偏导 H 和 优势估计一阶偏导g的的矩阵乘积\n",
    "            Hp = self.hessian_matrix_vector_product(states, old_action_dists, p)\n",
    "            ## 算 alpha也就是步长，在方向向量 update 的步长\n",
    "            alpha = rdotr / torch.dot(p, Hp)\n",
    "            x += alpha * p  ## update线性方程组 Hx=g 的答案 x，步长是 alpha\n",
    "            r -= alpha * Hp   ## update 一阶偏导的残差，或者说是一阶偏导数\n",
    "            new_rdotr = torch.dot(r, r)  ## 用来运算求出 下一个方向向量的，或者用来求出 alpha\n",
    "            if new_rdotr < 1e-10: ## 基本收敛的，此时alpha 步长也很小了，可以退出循环\n",
    "                break\n",
    "            beta = new_rdotr / rdotr  ## 用来运算求出 下一个方向向量的\n",
    "            p = r + beta * p  ## 求出下一个方向向量的\n",
    "            rdotr = new_rdotr  ## 赋值\n",
    "        return x ## 返回 Hx=g 这个线性方程组的答案 x\n",
    "\n",
    "    def compute_surrogate_obj(self, states, actions, advantage, old_log_probs,\n",
    "                              actor):  # 计算策略目标\n",
    "        ## 由于策略可能还没有update，也就是同一个策略，此时的 log_probs = old_log_probs, 像函数 policy_learn内的compute_surrogate_obj\n",
    "        mu, std = actor(states)\n",
    "        action_dists = torch.distributions.Normal(mu, std)\n",
    "        log_probs = action_dists.log_prob(actions)\n",
    "        ## 若策略还没有update，残差是0，此时取指数就是 ratio = 1，像函数 policy_learn内的compute_surrogate_obj\n",
    "        ## 也就是 重要性采样，log相减也就是log内相除，最后取指数就是  (当前策略动作的概率 / 旧策略动作的概率)\n",
    "        ratio = torch.exp(log_probs - old_log_probs)\n",
    "        '''\n",
    "        ## 两个策略的动作概率残差取指数，当作优势函数值的权重，均衡当前的广义优势估计，也就是每一步优势的均值\n",
    "        若 log_probs - old_log_probs > 0，也就是动作概率变大了，则ratio > 1，此时放大了 广义优势估计\n",
    "        若 log_probs - old_log_probs < 0，也就是动作概率变小了，则ratio < 1，此时缩小了 广义优势估计\n",
    "        若 log_probs - old_log_probs = 0, 动作概率保持不变的，或者策略还没有update，则ratio = 1, 此时保持不变的\n",
    "        重要性采样 \n",
    "        '''\n",
    "        return torch.mean(ratio * advantage) ## 对广义优势估计做均衡化，并求出平均值\n",
    "\n",
    "    ## old_log_probs和old_action_dists 在传入前已经detach了，不需要反向传播求梯度\n",
    "    def line_search(self, states, actions, advantage, old_log_probs,\n",
    "                    old_action_dists, max_vec):  # 线性搜索\n",
    "        ## 拿到策略网络的参数，并向量化的，返回参数的向量，这个向量是列向量，也就是只有一列\n",
    "        old_para = torch.nn.utils.convert_parameters.parameters_to_vector(self.actor.parameters())\n",
    "        ## 算重要性采样，对广义优势估计做均衡，也就是两个策略的动作概率残差并取指数，当作均衡因子的，也就是重要性采样，用来算出广义优势估计的平均值\n",
    "        old_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                             old_log_probs, self.actor)\n",
    "        for i in range(15):  # 线性搜索主循环\n",
    "            coef = self.alpha**i  ## 搜索的相关因子，每次指数次 +1\n",
    "            new_para = old_para + coef * max_vec   ## 根号 * X，然后coef来调整，拿到update以后的策略网络的参数\n",
    "            new_actor = copy.deepcopy(self.actor)  ## 深度拷贝的网络\n",
    "            torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "                new_para, new_actor.parameters())  ## 将update以后的网络参数赋值给 深度拷贝的网络\n",
    "            mu, std = new_actor(states)\n",
    "            new_action_dists = torch.distributions.Normal(mu, std)  ## update以后网络动作的分布\n",
    "            kl_div = torch.mean(  ## 算旧网络动作的分布，和update以后网络动作的分布，之间的KL散度，用来判断 KL 散度是否满足要求\n",
    "                torch.distributions.kl.kl_divergence(old_action_dists,\n",
    "                                                     new_action_dists))\n",
    "            ## 使用update以后的策略网络来算重要性采样，然后算广义优势估计，用来判断优势是否上升\n",
    "            new_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                                 old_log_probs, new_actor)\n",
    "            ## 若优势上升了，并且 KL散度也满足限制条件，就可以退出循环，并返回 update 以后的策略网络的参数\n",
    "            if new_obj > old_obj and kl_div < self.kl_constraint:\n",
    "                return new_para\n",
    "        return old_para ## 若是没找到满足条件的策略参数，那么就返回旧策略的\n",
    "\n",
    "    '''\n",
    "    old_log_probs和old_action_dists 在传入前已经detach了，不需要反向传播求梯度\n",
    "    '''\n",
    "    def policy_learn(self, states, actions, old_action_dists, old_log_probs,\n",
    "                     advantage):  # 更新策略函数\n",
    "        ## 算重要性采样，对广义优势估计做均衡，也就是两个策略的动作概率残差并取指数，当作均衡因子的，也就是重要性采样，用来算出广义优势估计的平均值\n",
    "        ## 此时策略的参数没有变化，所以此时的均衡因子是一\n",
    "        surrogate_obj = self.compute_surrogate_obj(states, actions, advantage, old_log_probs, self.actor)\n",
    "        '''\n",
    "        对重要性采样以后的广义优势估计的平均值，反向传播求出 策略网络 self.actor 参数的梯度\n",
    "        也就是 self.compute_surrogate_obj 函数内 log_probs = torch.log(actor(states).gather(1, actions)) 的梯度\n",
    "        拿到优势估计策略网络参数的 一阶偏导数\n",
    "        '''\n",
    "        grads = torch.autograd.grad(surrogate_obj, self.actor.parameters())\n",
    "        ## 对优势估计策略网络参数的一阶偏导数，列化，然后拼在一起的\n",
    "        obj_grad = torch.cat([grad.view(-1) for grad in grads]).detach()\n",
    "        \n",
    "        '''\n",
    "        求出线性方程组的解，不需要存储二阶偏导数的矩阵\n",
    "        参数分别是 （obj_grad：当前策略网络的一阶偏导数，states：当前状态的，old_action_dists：当前策略网络的动作分布）\n",
    "        old_action_dists 在传入前已经detach了，不需要反向传播求梯度\n",
    "        '''\n",
    "        # 用共轭梯度法计算x = H^(-1)g\n",
    "        ## Hx = g，g=grad是使用策略网络算广义优势估计时的一阶偏导数，H是算KL散度时的二阶偏导数\n",
    "        ## obj_grad 也就是使用策略网络在重要性采样广义优势估计时的一阶偏导数 g\n",
    "        descent_direction = self.conjugate_gradient(obj_grad, states,\n",
    "                                                    old_action_dists)\n",
    "        ## Hx   x^THx 内的 Hx，也就是KL散度二阶偏导 H 和 上面求出的线性方程组的答案 x，做矩阵运算的\n",
    "        Hd = self.hessian_matrix_vector_product(states, old_action_dists, descent_direction)\n",
    "        ## 求出策略网络参数 update 的步长，也就是根号内的内容\n",
    "        max_coef = torch.sqrt(2 * self.kl_constraint / (torch.dot(descent_direction, Hd) + 1e-8))\n",
    "        ## descent_direction * max_coef 是策略网络参数 update 时的内容，也就是 根号 * X\n",
    "        new_para = self.line_search(states, actions, advantage, old_log_probs,\n",
    "                                    old_action_dists,\n",
    "                                    descent_direction * max_coef)  # 线性搜索\n",
    "        torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "            new_para, self.actor.parameters())  # 用线性搜索后的参数更新策略\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        ## 拿到这条序列内的 奖励、状态和动作，下一个状态、是否完成的\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        rewards = (rewards + 8.0) / 8.0  # 对奖励进行修改,方便训练\n",
    "        ## 用下个状态求下一个状态的状态动作价值，然后间接求出当前状态的状态动作价值\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 - dones)\n",
    "        td_delta = td_target - self.critic(states)  ## 间接求出的价值 - 直接求出的当前状态的状态动作价值，也就是 TD-error，或者是优势函数 A\n",
    "        ## 直接求出当前状态的状态动作价值，和 间接求出的价值，使用 MSE 来算损失函数的，不反向传播求梯度，detach\n",
    "        critic_loss = torch.mean(\n",
    "            F.mse_loss(self.critic(states), td_target.detach()))\n",
    "        self.critic_optimizer.zero_grad()      ## 价值网络的优化器置零的\n",
    "        critic_loss.backward()  ## 价值网络的损失loss反向传播梯度\n",
    "        self.critic_optimizer.step()   # 更新价值函数\n",
    "        \n",
    "        ##  算出优势函数值   广义优势估计，也就是平均值的\n",
    "        advantage = compute_advantage(self.gamma, self.lmbda, td_delta.cpu()).to(self.device)\n",
    "        mu, std = self.actor(states)  ## 拿到 continuous 动作分布的均值和方差\n",
    "         ## 所有动作概率的分布，不反向传播求梯度，detach，给定正态分布的均值和方差，产生正态分布的\n",
    "        old_action_dists = torch.distributions.Normal(mu.detach(),\n",
    "                                                      std.detach())\n",
    "        ## 从产生的正态分布，给出每个动作的概率 log 值\n",
    "        old_log_probs = old_action_dists.log_prob(actions)\n",
    "        # 更新策略函数 ## 不使用优化器来update，而是直接算的\n",
    "        self.policy_learn(states, actions, old_action_dists, old_log_probs,\n",
    "                          advantage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 747
    },
    "executionInfo": {
     "elapsed": 233402,
     "status": "ok",
     "timestamp": 1649956314084,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "e0qF7lu0_SlM",
    "outputId": "f29a86f6-6f69-4dad-ea9a-979189c0f253"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|████████████████████████████████████| 200/200 [00:24<00:00,  8.07it/s, episode=200, return=-1115.591]\n",
      "Iteration 1: 100%|████████████████████████████████████| 200/200 [00:24<00:00,  8.14it/s, episode=400, return=-1030.641]\n",
      "Iteration 2: 100%|█████████████████████████████████████| 200/200 [00:26<00:00,  7.68it/s, episode=600, return=-894.173]\n",
      "Iteration 3: 100%|█████████████████████████████████████| 200/200 [00:23<00:00,  8.48it/s, episode=800, return=-761.867]\n",
      "Iteration 4: 100%|████████████████████████████████████| 200/200 [00:24<00:00,  8.25it/s, episode=1000, return=-757.232]\n",
      "Iteration 5: 100%|████████████████████████████████████| 200/200 [00:23<00:00,  8.35it/s, episode=1200, return=-491.535]\n",
      "Iteration 6: 100%|████████████████████████████████████| 200/200 [00:22<00:00,  8.77it/s, episode=1400, return=-471.162]\n",
      "Iteration 7: 100%|████████████████████████████████████| 200/200 [00:22<00:00,  8.83it/s, episode=1600, return=-236.269]\n",
      "Iteration 8: 100%|████████████████████████████████████| 200/200 [00:26<00:00,  7.63it/s, episode=1800, return=-476.572]\n",
      "Iteration 9: 100%|████████████████████████████████████| 200/200 [00:24<00:00,  8.33it/s, episode=2000, return=-366.641]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_episodes = 2000\n",
    "hidden_dim = 128\n",
    "gamma = 0.9\n",
    "lmbda = 0.9\n",
    "critic_lr = 1e-2\n",
    "kl_constraint = 0.00005\n",
    "alpha = 0.5\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = 'Pendulum-v1'\n",
    "env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "_ = env.reset(seed=0)\n",
    "torch.manual_seed(0)\n",
    "agent = TRPOContinuous(hidden_dim, env.observation_space, env.action_space,\n",
    "                       lmbda, kl_constraint, alpha, critic_lr, gamma, device)\n",
    "return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "# Iteration 0: 100%|██████████| 200/200 [00:19<00:00, 10.00it/s, episode=200,\n",
    "# return=-1181.390]\n",
    "# Iteration 1: 100%|██████████| 200/200 [00:20<00:00,  9.98it/s, episode=400,\n",
    "# return=-994.876]\n",
    "# Iteration 2: 100%|██████████| 200/200 [00:20<00:00,  9.86it/s, episode=600,\n",
    "# return=-888.498]\n",
    "# Iteration 3: 100%|██████████| 200/200 [00:20<00:00,  9.94it/s, episode=800,\n",
    "# return=-848.329]\n",
    "# Iteration 4: 100%|██████████| 200/200 [00:20<00:00,  9.87it/s, episode=1000,\n",
    "# return=-772.392]\n",
    "# Iteration 5: 100%|██████████| 200/200 [00:20<00:00,  9.91it/s, episode=1200,\n",
    "# return=-611.870]\n",
    "# Iteration 6: 100%|██████████| 200/200 [00:20<00:00,  9.89it/s, episode=1400,\n",
    "# return=-397.705]\n",
    "# Iteration 7: 100%|██████████| 200/200 [00:20<00:00,  9.95it/s, episode=1600,\n",
    "# return=-268.498]\n",
    "# Iteration 8: 100%|██████████| 200/200 [00:20<00:00,  9.87it/s, episode=1800,\n",
    "# return=-408.976]\n",
    "# Iteration 9: 100%|██████████| 200/200 [00:19<00:00, 10.08it/s, episode=2000,\n",
    "# return=-296.363]"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "第11章-TRPO算法.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
